{
"schemaVersion": 1,
"taskId": "yambda-discovery-ranking-two-tower-case-1",
"attemptId": "gemini-3-8-flash-high-case1-fixed-r05-3d6fca60",
"taskChecksum": "8404d794ce8e18d154cd225cfe6b12bf6b4ee02aaefba1d315aa215c1175a013",
"agentVersion": "0.61.0",
"model": "gemini-3.8-flash",
"sessionId": "5b21a254-66d2-4985-a371-9459e907571a",
"steps": [
{
"id": 1,
"role": "user",
"timestamp": "2026-09-29T05:36:37.309Z",
"blocks": [
{
"kind": "message",
"timestamp": "2026-09-29T05:36:37.309Z",
"text": "\nThis is the Gemini CLI. We are setting up the context for our chat.\nToday's date is Tuesday, September 29, 2026 (formatted according to the user's locale).\nMy operating system is: linux\nThe project's temporary directory is: /home/agent/.gemini/tmp/app\n- **Workspace Directories:**\n - /app\n - /task\n- **Directory Structure:**\n\nShowing up to 200 items (files + folders).\n\n/app/\n└───solution/\nShowing up to 200 items (files + folders).\n\n/task/\n├───.keep\n├───evaluate_public.py\n├───ranking_evaluation.py\n├───requirements.txt\n├───current_model/\n│ ├───train_current_model.py\n│ └───two_tower_model.py\n└───data/\n ├───candidate_catalog.parquet\n ├───target_users.parquet\n ├───test_eligible_candidates.npz\n ├───test_preference_state.parquet\n ├───train_dislikes.parquet\n ├───train_likes.parquet\n ├───train_listens.parquet\n ├───train_undislikes.parquet\n ├───train_unlikes.parquet\n ├───val_dislikes.parquet\n ├───val_likes.parquet\n ├───val_listens.parquet\n ├───val_undislikes.parquet\n ├───val_unlikes.parquet\n ├───validation_eligible_candidates.npz\n └───validation_preference_state.parquet\n\n\n"
}
]
},
{
"id": 2,
"role": "user",
"timestamp": "2026-09-29T05:36:37.354Z",
"blocks": [
{
"kind": "message",
"timestamp": "2026-09-29T05:36:37.354Z",
"text": "# Improve a production music-discovery two-tower\n\nYou have joined the recommendations team for a music streaming service. The\n\"Made for You\" shelf is served by a mature production two-tower model. Its\nchronological data protocol and indexed serving path are sound, but its offline\nretrieval quality no longer clears the team's next launch gate.\n\nYour job is to investigate the production model, improve its retrieval quality,\nand ship a better ranking artifact. Use the implementation and public validation\ndata to form and test your own diagnosis.\n\nThe source used to reproduce the production model is included under\n`/task/current_model/`. You may copy it into `/app/solution/`, edit it, add\ntests, and improve its training objective, but keep the data protocol,\ntwo-tower serving contract, and evaluation boundary intact.\n\n## Production Context\n\nThe model must satisfy a strict request-time latency budget. Item vectors are\nprecomputed offline. At request time, one user vector is computed from observed\ninteraction history and compared with candidate item vectors by a batchable\ntwo-tower score. Do not introduce a cross-encoder, per-candidate sequence model,\nor user-ID lookup table.\n\nThe current trainer is a mature baseline with chronological internal\nvalidation. Focus your investigation on how its training objective selects and\nuses negative examples. Diagnose limitations in the current negative-sampling\nstrategy and improve it under the fixed CPU budget. Validate changes with the\npublic backtest. The final approach must still train and rank within the supplied\nCPU environment while preserving the serving and data boundaries above.\n\n## What You Have\n\nAll public inputs are under `/task/data/`. A stage cutoff is the timestamp at\nwhich observed history and candidate eligibility are frozen for a ranking. The\npublic validation stage cutoff is `24786800`, when `train_*` ends. A 30-minute\ngap precedes the seven-day `val_*` window. For the final submission, that\nvalidation window becomes observed history, and another 30-minute gap precedes\nthe hidden seven-day outcome window.\n\nThe package includes:\n\n- `/task/current_model/train_current_model.py`: the production training and\n ranking script. It can reproduce the public validation ranking and produce a\n hidden-test submission after refitting.\n- `/task/current_model/two_tower_model.py`: model primitives used by the\n production script.\n- `/task/evaluate_public.py`: the public validation evaluator for development.\n- `/task/data/validation_eligible_candidates.npz` and\n `/task/data/test_eligible_candidates.npz`: platform-owned candidate sets for\n the validation and hidden-test cutoffs.\n- `/task/data/validation_preference_state.parquet` and\n `/task/data/test_preference_state.parquet`: active explicit preference state\n at the corresponding cutoffs.\n- `/task/requirements.txt`: the exact offline Python distribution inventory.\n\nYou can reproduce the production public backtest with:\n\n```sh\npython /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --output /app/solution/production_validation.parquet\npython /task/evaluate_public.py /app/solution/production_validation.parquet\n```\n\n## Data\n\nFor each event family there is a `train_*.parquet` and `val_*.parquet` file:\n\n| Family | Meaning | Columns |\n| --- | --- | --- |\n| `listens` | Playback events | `uid`, `timestamp`, `item_id`, `is_organic`, `played_ratio_pct`, `track_length_seconds` |\n| `likes` | Explicit positive actions | `uid`, `timestamp`, `item_id`, `is_organic` |\n| `dislikes` | Explicit negative actions | `uid`, `timestamp`, `item_id`, `is_organic` |\n| `unlikes` | Reversal of a prior like | `uid`, `timestamp`, `item_id`, `is_organic` |\n| `undislikes` | Reversal of a prior dislike | `uid`, `timestamp`, `item_id`, `is_organic` |\n\n`is_organic=1` means the listener sought out the track; `0` means the action came\nthrough a recommendation surface. A listen is a conventional positive at 50%\ncompletion. The discovery-quality objective below uses the stronger 80%\nthreshold.\n\nThe two public windows have different roles:\n\n1. For model development and selection, train only from `train_*` and score the\n subsequent `val_*` outcomes.\n2. After selecting an improvement, refit it on `train_* + val_*`. At hidden-test\n time the validation events are observed history, not recommendable outcomes.\n\nDo not use `val_*` events as features when measuring a validation ranking. They\nmay and should be used when refitting the final hidden-test ranker.\n\nAdditional files under `/task/data/`:\n\n- `candidate_catalog.parquet`: the 30,000 retrieval-catalog tracks, ordered by\n training positive-listen popularity.\n- `target_users.parquet`: users with at least 20 positive listens in the 90 days\n before the training cutoff, selected without future labels.\n- `validation_preference_state.parquet`: active explicit state at the training\n cutoff, for validation ranking.\n- `test_preference_state.parquet`: active explicit state after validation, for\n the final hidden-test ranking. State is `liked` or `disliked`; a pair may have\n both active channels.\n- `validation_eligible_candidates.npz` and `test_eligible_candidates.npz`:\n cutoff-correct candidate sets for every target user. Each contains aligned\n arrays `uids`, `item_ids`, and `packed_eligible`. For user row `r`, recover\n the Boolean item mask with `np.unpackbits(packed_eligible[r],\n count=len(item_ids), bitorder=\"little\")`.\n\nValidation candidates exclude all `train_*` encounters. Test candidates exclude\nall `train_*` and `val_*` encounters. Future test interactions are hidden and\nused only by the separate Harbor verifier.\n\n## Discovery Objective\n\nRank only the candidates returned for the relevant cutoff. Relevance is based\non organic behavior in the immediately following window:\n\n- grade 3: the user organically likes the track;\n- grade 1: the user organically listens to at least 80% of the track;\n- grade 0: otherwise.\n\nIf both positive events occur, grade 3 wins. Ranking quality is measured with\ngraded NDCG@10. DCG uses gain `2^grade - 1` and discount\n`1/log2(rank + 1)`, then averages per-user NDCG over users with at least one\nrelevant item.\n\nThe public evaluator reports this same objective for development, but its score\nis not a separate acceptance stage. Final acceptance is determined on the\nhidden test using the same objective. The Yambda logs contain interactions, not\nimpression propensities; treat the organic objective as a robust offline target,\nnot as a causal estimate of online lift.\n\n## Deliverable\n\nSubmit one final ranking as `/app/solution/submission.parquet` or\n`/app/solution/submission.csv`. It must be a regular file, not a symbolic link.\nIf both files exist, the verifier evaluates `submission.parquet` and ignores\n`submission.csv`.\n\nThe ranking must:\n\n- include the columns `uid`, `item_id`, and `rank`; only these columns are\n evaluated;\n- use finite, integer-valued entries in all three required columns;\n- cover exactly the users in `target_users.parquet`, with no missing or extra\n users;\n- contain exactly 100 rows and 100 distinct items for every target user;\n- contain every integer rank from 1 through 100 exactly once per user; and\n- use only items present in that user's `test_eligible_candidates.npz`\n candidate set.\n\nAlso leave the improved implementation used to build the artifact at\n`/app/solution/train_current_model.py`, along with any local modules it imports.\nA concise `/app/solution/README.md` with the diagnosis, before-and-after public\nscore, model change, and submission command is useful for the experiment record,\nbut it is not an automated acceptance gate.\n\n## Constraints\n\n- Write deliverables and intermediate artifacts only under `/app/solution/`.\n- Treat `/task/` and the installed Python environment as read-only.\n- Do not invoke nested agents or attempt to access verifier files, credentials,\n other trials, or host paths.\n- Do not install packages or use network access except for the model-provider\n connection managed by Harbor.\n- Do not alter cutoff definitions, target users, candidate eligibility, or\n relevance labels.\n- Improve the production pipeline in place. Do not substitute an unrelated\n model family or evade the indexed two-tower serving constraint.\n- The environment includes CPU PyTorch 2.8.0. No accelerator is available.\n- You have up to 60 minutes. Prioritize measured validation improvements, a\n correct final refit, and a valid submission over broad architecture search.\n- Keep the best valid submission saved throughout the attempt so it survives\n the deadline.\n"
}
]
},
{
"id": 3,
"role": "agent",
"timestamp": "2026-09-29T05:36:43.270Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:36:43.270Z",
"text": "Analyzing Initial Mandates\n\nMy current focus is on deconstructing the prompt and identifying the core directives. I'm performing a preliminary assessment of available tools and the explicit requirement to initiate a topic update immediately."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:36:43.270Z",
"text": "Refining Retrieval Strategies\n\nI'm now concentrating on enhancing the offline retrieval aspect of the two-tower music discovery model. My aim is to ensure the output precisely matches the specified format, containing 100 distinct items ranked 1-100 for each target user, drawn solely from their eligible candidate sets."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:36:43.270Z",
"callId": "update_topic__call_3322292",
"name": "update_topic",
"input": {
"strategic_intent": "Explore the codebase and understand the current two-tower model and evaluation pipeline.",
"summary": "Starting investigation into the production two-tower music discovery model. I will inspect the current model training code, model architecture, evaluation script, and data layout to diagnose negative sampling limitations and understand baseline performance.",
"title": "Initial Codebase and Baseline Investigation"
},
"recorded": {
"id": "update_topic__call_3322292",
"name": "update_topic",
"args": {
"strategic_intent": "Explore the codebase and understand the current two-tower model and evaluation pipeline.",
"summary": "Starting investigation into the production two-tower music discovery model. I will inspect the current model training code, model architecture, evaluation script, and data layout to diagnose negative sampling limitations and understand baseline performance.",
"title": "Initial Codebase and Baseline Investigation"
},
"result": [
{
"functionResponse": {
"id": "update_topic__call_3322292",
"name": "update_topic",
"response": {
"output": "Current topic: \"Initial Codebase and Baseline Investigation\"\nTopic summary: Starting investigation into the production two-tower music discovery model. I will inspect the current model training code, model architecture, evaluation script, and data layout to diagnose negative sampling limitations and understand baseline performance.\n\nStrategic Intent: Explore the codebase and understand the current two-tower model and evaluation pipeline."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:36:43.303Z",
"resultDisplay": "## 📂 Topic: **Initial Codebase and Baseline Investigation**\n\n**Summary:**\nStarting investigation into the production two-tower music discovery model. I will inspect the current model training code, model architecture, evaluation script, and data layout to diagnose negative sampling limitations and understand baseline performance.\n\n> [!STRATEGY]\n> **Intent:** Explore the codebase and understand the current two-tower model and evaluation pipeline.",
"description": "Update topic to: \"Initial Codebase and Baseline Investigation\"",
"displayName": "Update Topic Context",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:36:43.304Z",
"content": "Current topic: \"Initial Codebase and Baseline Investigation\"\nTopic summary: Starting investigation into the production two-tower music discovery model. I will inspect the current model training code, model architecture, evaluation script, and data layout to diagnose negative sampling limitations and understand baseline performance.\n\nStrategic Intent: Explore the codebase and understand the current two-tower model and evaluation pipeline.",
"isError": false
},
"responseMessageId": "6d7fc086-46d0-48c9-ae84-4018a351fd15"
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:36:43.270Z",
"callId": "run_shell_command__call_3322296",
"name": "run_shell_command",
"input": {
"description": "List task directory contents",
"command": "ls -la /task /task/current_model /task/data"
},
"recorded": {
"id": "run_shell_command__call_3322296",
"name": "run_shell_command",
"args": {
"description": "List task directory contents",
"command": "ls -la /task /task/current_model /task/data"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_3322296",
"name": "run_shell_command",
"response": {
"output": "\nOutput: /task:\ntotal 40\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 .\ndrwxr-xr-x 1 root root 4096 Sep 29 05:36 ..\n-r--r--r-- 1 root root 0 Sep 29 05:31 .keep\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 current_model\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 data\n-r--r--r-- 1 root root 5774 Sep 29 05:31 evaluate_public.py\n-r--r--r-- 1 root root 8265 Sep 29 05:31 ranking_evaluation.py\n-r--r--r-- 1 root root 1295 Sep 29 05:31 requirements.txt\n\n/task/current_model:\ntotal 104\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 80058 Sep 29 05:31 train_current_model.py\n-r--r--r-- 1 root root 15985 Sep 29 05:31 two_tower_model.py\n\n/task/data:\ntotal 347392\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 349352 Sep 29 05:31 candidate_catalog.parquet\n-r--r--r-- 1 root root 84127 Sep 29 05:31 target_users.parquet\n-r--r--r-- 1 root root 7736341 Sep 29 05:31 test_eligible_candidates.npz\n-r--r--r-- 1 root root 1092329 Sep 29 05:32 test_preference_state.parquet\n-r--r--r-- 1 root root 857213 Sep 29 05:31 train_dislikes.parquet\n-r--r--r-- 1 root root 5374652 Sep 29 05:31 train_likes.parquet\n-r--r--r-- 1 root root 319183255 Sep 29 05:31 train_listens.parquet\n-r--r--r-- 1 root root 155988 Sep 29 05:31 train_undislikes.parquet\n-r--r--r-- 1 root root 1855885 Sep 29 05:31 train_unlikes.parquet\n-r--r--r-- 1 root root 36571 Sep 29 05:31 val_dislikes.parquet\n-r--r--r-- 1 root root 298484 Sep 29 05:31 val_likes.parquet\n-r--r--r-- 1 root root 9947609 Sep 29 05:31 val_listens.parquet\n-r--r--r-- 1 root root 7845 Sep 29 05:31 val_undislikes.parquet\n-r--r--r-- 1 root root 72536 Sep 29 05:31 val_unlikes.parquet\n-r--r--r-- 1 root root 7573821 Sep 29 05:31 validation_eligible_candidates.npz\n-r--r--r-- 1 root root 1061761 Sep 29 05:32 validation_preference_state.parquet\nProcess Group PGID: 1612\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:36:43.303Z",
"resultDisplay": "/task:\ntotal 40\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 .\ndrwxr-xr-x 1 root root 4096 Sep 29 05:36 ..\n-r--r--r-- 1 root root 0 Sep 29 05:31 .keep\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 current_model\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 data\n-r--r--r-- 1 root root 5774 Sep 29 05:31 evaluate_public.py\n-r--r--r-- 1 root root 8265 Sep 29 05:31 ranking_evaluation.py\n-r--r--r-- 1 root root 1295 Sep 29 05:31 requirements.txt\n\n/task/current_model:\ntotal 104\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 80058 Sep 29 05:31 train_current_model.py\n-r--r--r-- 1 root root 15985 Sep 29 05:31 two_tower_model.py\n\n/task/data:\ntotal 347392\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 349352 Sep 29 05:31 candidate_catalog.parquet\n-r--r--r-- 1 root root 84127 Sep 29 05:31 target_users.parquet\n-r--r--r-- 1 root root 7736341 Sep 29 05:31 test_eligible_candidates.npz\n-r--r--r-- 1 root root 1092329 Sep 29 05:32 test_preference_state.parquet\n-r--r--r-- 1 root root 857213 Sep 29 05:31 train_dislikes.parquet\n-r--r--r-- 1 root root 5374652 Sep 29 05:31 train_likes.parquet\n-r--r--r-- 1 root root 319183255 Sep 29 05:31 train_listens.parquet\n-r--r--r-- 1 root root 155988 Sep 29 05:31 train_undislikes.parquet\n-r--r--r-- 1 root root 1855885 Sep 29 05:31 train_unlikes.parquet\n-r--r--r-- 1 root root 36571 Sep 29 05:31 val_dislikes.parquet\n-r--r--r-- 1 root root 298484 Sep 29 05:31 val_likes.parquet\n-r--r--r-- 1 root root 9947609 Sep 29 05:31 val_listens.parquet\n-r--r--r-- 1 root root 7845 Sep 29 05:31 val_undislikes.parquet\n-r--r--r-- 1 root root 72536 Sep 29 05:31 val_unlikes.parquet\n-r--r--r-- 1 root root 7573821 Sep 29 05:31 validation_eligible_candidates.npz\n-r--r--r-- 1 root root 1061761 Sep 29 05:32 validation_preference_state.parquet",
"description": "ls -la /task /task/current_model /task/data",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:36:43.304Z",
"content": "\nOutput: /task:\ntotal 40\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 .\ndrwxr-xr-x 1 root root 4096 Sep 29 05:36 ..\n-r--r--r-- 1 root root 0 Sep 29 05:31 .keep\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 current_model\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 data\n-r--r--r-- 1 root root 5774 Sep 29 05:31 evaluate_public.py\n-r--r--r-- 1 root root 8265 Sep 29 05:31 ranking_evaluation.py\n-r--r--r-- 1 root root 1295 Sep 29 05:31 requirements.txt\n\n/task/current_model:\ntotal 104\ndr-xr-xr-x 1 root root 4096 Sep 29 05:31 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 80058 Sep 29 05:31 train_current_model.py\n-r--r--r-- 1 root root 15985 Sep 29 05:31 two_tower_model.py\n\n/task/data:\ntotal 347392\ndr-xr-xr-x 1 root root 4096 Sep 29 05:32 .\ndr-xr-xr-x 1 root root 4096 Sep 29 05:33 ..\n-r--r--r-- 1 root root 349352 Sep 29 05:31 candidate_catalog.parquet\n-r--r--r-- 1 root root 84127 Sep 29 05:31 target_users.parquet\n-r--r--r-- 1 root root 7736341 Sep 29 05:31 test_eligible_candidates.npz\n-r--r--r-- 1 root root 1092329 Sep 29 05:32 test_preference_state.parquet\n-r--r--r-- 1 root root 857213 Sep 29 05:31 train_dislikes.parquet\n-r--r--r-- 1 root root 5374652 Sep 29 05:31 train_likes.parquet\n-r--r--r-- 1 root root 319183255 Sep 29 05:31 train_listens.parquet\n-r--r--r-- 1 root root 155988 Sep 29 05:31 train_undislikes.parquet\n-r--r--r-- 1 root root 1855885 Sep 29 05:31 train_unlikes.parquet\n-r--r--r-- 1 root root 36571 Sep 29 05:31 val_dislikes.parquet\n-r--r--r-- 1 root root 298484 Sep 29 05:31 val_likes.parquet\n-r--r--r-- 1 root root 9947609 Sep 29 05:31 val_listens.parquet\n-r--r--r-- 1 root root 7845 Sep 29 05:31 val_undislikes.parquet\n-r--r--r-- 1 root root 72536 Sep 29 05:31 val_unlikes.parquet\n-r--r--r-- 1 root root 7573821 Sep 29 05:31 validation_eligible_candidates.npz\n-r--r--r-- 1 root root 1061761 Sep 29 05:32 validation_preference_state.parquet\nProcess Group PGID: 1612\n",
"isError": false
},
"responseMessageId": "6d7fc086-46d0-48c9-ae84-4018a351fd15"
}
]
},
{
"id": 4,
"role": "agent",
"timestamp": "2026-09-29T05:36:45.647Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:36:45.647Z",
"callId": "run_shell_command__call_5336834",
"name": "run_shell_command",
"input": {
"command": "nproc && free -h && python --version",
"description": "Check CPU count, memory, and python version"
},
"recorded": {
"id": "run_shell_command__call_5336834",
"name": "run_shell_command",
"args": {
"command": "nproc && free -h && python --version",
"description": "Check CPU count, memory, and python version"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5336834",
"name": "run_shell_command",
"response": {
"output": "\nOutput: 8\n/usr/bin/bash: line 4: free: command not found\nExit Code: 127\nProcess Group PGID: 1615\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:36:45.666Z",
"resultDisplay": "8\n/usr/bin/bash: line 4: free: command not found",
"description": "nproc && free -h && python --version",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:36:45.667Z",
"content": "\nOutput: 8\n/usr/bin/bash: line 4: free: command not found\nExit Code: 127\nProcess Group PGID: 1615\n",
"isError": false
},
"responseMessageId": "f747a3b2-4f07-4b4d-be4d-cd6d75ea176c"
}
]
},
{
"id": 5,
"role": "agent",
"timestamp": "2026-09-29T05:36:47.358Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:36:47.358Z",
"callId": "run_shell_command__call_5336864",
"name": "run_shell_command",
"input": {
"command": "cat /proc/meminfo | grep MemTotal && python -c \"import torch; print(torch.__version__)\"",
"description": "Check system RAM and PyTorch version"
},
"recorded": {
"id": "run_shell_command__call_5336864",
"name": "run_shell_command",
"args": {
"command": "cat /proc/meminfo | grep MemTotal && python -c \"import torch; print(torch.__version__)\"",
"description": "Check system RAM and PyTorch version"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5336864",
"name": "run_shell_command",
"response": {
"output": "\nOutput: MemTotal: 15988964 kB\n2.8.0+cpu\nProcess Group PGID: 1625\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:36:50.272Z",
"resultDisplay": "MemTotal: 15988964 kB\n2.8.0+cpu",
"description": "cat /proc/meminfo | grep MemTotal && python -c \"import torch; print(torch.__version__)\"",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:36:50.273Z",
"content": "\nOutput: MemTotal: 15988964 kB\n2.8.0+cpu\nProcess Group PGID: 1625\n",
"isError": false
},
"responseMessageId": "7d6b50b0-dd33-45c6-a9de-6ec3820a0990"
}
]
},
{
"id": 6,
"role": "agent",
"timestamp": "2026-09-29T05:36:52.183Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:36:52.183Z",
"callId": "read_file__call_143285",
"name": "read_file",
"input": {
"start_line": 1,
"file_path": "/task/evaluate_public.py"
},
"recorded": {
"id": "read_file__call_143285",
"name": "read_file",
"args": {
"start_line": 1,
"file_path": "/task/evaluate_public.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_143285",
"name": "read_file",
"response": {
"output": "#!/usr/bin/env python3\n\"\"\"Score a validation-stage ranking against public discovery labels.\n\n``build_task.py`` publishes this module with the solver-visible task files. It\nloads target users, validation eligibility, and validation-window events from\nthe adjacent ``data`` directory, then evaluates one ranking supplied on the\ncommand line. Stage-independent mechanics come from the adjacent public\n``ranking_evaluation.py`` module. The builder installs the same checked-in\nmodule in the private judge, so public and private scoring mechanics cannot\ndrift. A relevant candidate receives grade 3 for an organic like or grade 1 for\nan organic listen with at least 80 percent completion; a like takes precedence\nwhen both events exist.\n\nBefore scoring, the ranking must contain exactly 100 distinct eligible items\nfor every target user, with integer-valued ``uid``, ``item_id``, and ``rank``\ncolumns and ranks 1 through 100 exactly once per user. Extra columns are\nignored. Quality is graded NDCG@10, averaged only over users who have at least\none eligible relevant item in the validation window.\n\nThe evaluator prints a JSON object containing the model path and scores. It\ndoes not apply the task's pass threshold; its purpose is model development and\nselection. The private judge applies the threshold to the final submission.\n\nUsage::\n\n python evaluate_public.py \n\"\"\"\nfrom __future__ import annotations\n\nimport json\nimport sys\nfrom pathlib import Path\n\nimport pandas as pd\n\nfrom ranking_evaluation import (\n CandidateSet,\n RankingValidationError,\n ranked_items,\n read_ranking,\n score_rankings,\n validate_ranking,\n)\n\n\nHERE = Path(__file__).resolve().parent\nDATA = HERE / \"data\"\nLISTEN_STRONG = 80\n\n\ndef validation_truth(\n eligibility: CandidateSet, targets: set[int]\n) -> dict[int, dict[int, int]]:\n \"\"\"Build cutoff-correct graded relevance from public validation events.\n\n Only target-user events for eligible candidates are retained. Organic\n listens completed to at least 80 percent receive grade 1, and organic likes\n receive grade 3. Repeated user-item events are collapsed, and processing\n likes second ensures that grade 3 wins over grade 1.\n\n Args:\n eligibility: Validation-cutoff candidate membership service.\n targets: Complete set of target user IDs.\n\n Returns:\n A nested ``uid -> item_id -> grade`` mapping. Users without an eligible\n relevant event are omitted.\n \"\"\"\n listens = pd.read_parquet(DATA / \"val_listens.parquet\")\n likes = pd.read_parquet(DATA / \"val_likes.parquet\")\n strong = listens[\n listens.uid.isin(targets)\n & (listens.is_organic == 1)\n & (listens.played_ratio_pct >= LISTEN_STRONG)\n ][[\"uid\", \"item_id\"]].drop_duplicates()\n organic_likes = likes[\n likes.uid.isin(targets) & (likes.is_organic == 1)\n ][[\"uid\", \"item_id\"]].drop_duplicates()\n\n graded: dict[int, dict[int, int]] = {}\n for raw_uid, raw_item in strong.itertuples(index=False, name=None):\n uid, item = int(raw_uid), int(raw_item)\n if eligibility.is_eligible(uid, item):\n graded.setdefault(uid, {})[item] = 1\n for raw_uid, raw_item in organic_likes.itertuples(index=False, name=None):\n uid, item = int(raw_uid), int(raw_item)\n if eligibility.is_eligible(uid, item):\n graded.setdefault(uid, {})[item] = 3\n return graded\n\n\ndef load_submission(\n path: Path, eligibility: CandidateSet, targets: set[int]\n) -> dict[int, list[int]]:\n \"\"\"Load and validate a public validation ranking.\n\n Files ending in ``.parquet`` are read as parquet; every other suffix is\n read as CSV. The required columns must be integer-valued, cover exactly the\n target-user set, contain 100 rows and ranks 1 through 100 per user, avoid\n duplicate user-item pairs, and contain only cutoff-eligible items.\n\n Args:\n path: Ranking file to read.\n eligibility: Validation-cutoff candidate membership service.\n targets: Exact set of users the ranking must cover.\n\n Returns:\n A ``uid -> ranked item IDs`` mapping ordered by ascending rank.\n\n Raises:\n ValueError: If the ranking violates the required schema or invariants.\n \"\"\"\n frame = validate_ranking(read_ranking(path), targets)\n if not all(\n eligibility.is_eligible(uid, item)\n for uid, item in frame[[\"uid\", \"item_id\"]].itertuples(index=False, name=None)\n ):\n raise RankingValidationError(\n \"submission contains an item rejected by eligibility service\"\n )\n return ranked_items(frame)\n\n\ndef score(\n ranked: dict[int, list[int]],\n graded: dict[int, dict[int, int]],\n) -> dict[str, float | int]:\n \"\"\"Aggregate per-user NDCG@10 over users with public relevance labels.\n\n Args:\n ranked: Ranked item IDs for every target user.\n graded: Eligible validation relevance keyed by user and item.\n\n Returns:\n The six-decimal ``quality_ndcg@10`` value and number of scored users.\n \"\"\"\n return score_rankings(ranked, graded)\n\n\ndef main() -> None:\n \"\"\"Run the public evaluator CLI and print its JSON score report.\"\"\"\n targets_frame = pd.read_parquet(DATA / \"target_users.parquet\")\n targets = set(targets_frame.uid.astype(int))\n eligibility = CandidateSet(DATA / \"validation_eligible_candidates.npz\")\n graded = validation_truth(eligibility, targets)\n\n if len(sys.argv) != 2:\n raise SystemExit(\n \"usage: evaluate_public.py \"\n )\n path = Path(sys.argv[1])\n ranked = load_submission(path, eligibility, targets)\n print(json.dumps({\"model\": str(path), \"scores\": score(ranked, graded)}, indent=2))\n\n\nif __name__ == \"__main__\":\n main()\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:36:52.188Z",
"resultDisplay": "",
"description": "../task/evaluate_public.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:36:52.189Z",
"content": "#!/usr/bin/env python3\n\"\"\"Score a validation-stage ranking against public discovery labels.\n\n``build_task.py`` publishes this module with the solver-visible task files. It\nloads target users, validation eligibility, and validation-window events from\nthe adjacent ``data`` directory, then evaluates one ranking supplied on the\ncommand line. Stage-independent mechanics come from the adjacent public\n``ranking_evaluation.py`` module. The builder installs the same checked-in\nmodule in the private judge, so public and private scoring mechanics cannot\ndrift. A relevant candidate receives grade 3 for an organic like or grade 1 for\nan organic listen with at least 80 percent completion; a like takes precedence\nwhen both events exist.\n\nBefore scoring, the ranking must contain exactly 100 distinct eligible items\nfor every target user, with integer-valued ``uid``, ``item_id``, and ``rank``\ncolumns and ranks 1 through 100 exactly once per user. Extra columns are\nignored. Quality is graded NDCG@10, averaged only over users who have at least\none eligible relevant item in the validation window.\n\nThe evaluator prints a JSON object containing the model path and scores. It\ndoes not apply the task's pass threshold; its purpose is model development and\nselection. The private judge applies the threshold to the final submission.\n\nUsage::\n\n python evaluate_public.py \n\"\"\"\nfrom __future__ import annotations\n\nimport json\nimport sys\nfrom pathlib import Path\n\nimport pandas as pd\n\nfrom ranking_evaluation import (\n CandidateSet,\n RankingValidationError,\n ranked_items,\n read_ranking,\n score_rankings,\n validate_ranking,\n)\n\n\nHERE = Path(__file__).resolve().parent\nDATA = HERE / \"data\"\nLISTEN_STRONG = 80\n\n\ndef validation_truth(\n eligibility: CandidateSet, targets: set[int]\n) -> dict[int, dict[int, int]]:\n \"\"\"Build cutoff-correct graded relevance from public validation events.\n\n Only target-user events for eligible candidates are retained. Organic\n listens completed to at least 80 percent receive grade 1, and organic likes\n receive grade 3. Repeated user-item events are collapsed, and processing\n likes second ensures that grade 3 wins over grade 1.\n\n Args:\n eligibility: Validation-cutoff candidate membership service.\n targets: Complete set of target user IDs.\n\n Returns:\n A nested ``uid -> item_id -> grade`` mapping. Users without an eligible\n relevant event are omitted.\n \"\"\"\n listens = pd.read_parquet(DATA / \"val_listens.parquet\")\n likes = pd.read_parquet(DATA / \"val_likes.parquet\")\n strong = listens[\n listens.uid.isin(targets)\n & (listens.is_organic == 1)\n & (listens.played_ratio_pct >= LISTEN_STRONG)\n ][[\"uid\", \"item_id\"]].drop_duplicates()\n organic_likes = likes[\n likes.uid.isin(targets) & (likes.is_organic == 1)\n ][[\"uid\", \"item_id\"]].drop_duplicates()\n\n graded: dict[int, dict[int, int]] = {}\n for raw_uid, raw_item in strong.itertuples(index=False, name=None):\n uid, item = int(raw_uid), int(raw_item)\n if eligibility.is_eligible(uid, item):\n graded.setdefault(uid, {})[item] = 1\n for raw_uid, raw_item in organic_likes.itertuples(index=False, name=None):\n uid, item = int(raw_uid), int(raw_item)\n if eligibility.is_eligible(uid, item):\n graded.setdefault(uid, {})[item] = 3\n return graded\n\n\ndef load_submission(\n path: Path, eligibility: CandidateSet, targets: set[int]\n) -> dict[int, list[int]]:\n \"\"\"Load and validate a public validation ranking.\n\n Files ending in ``.parquet`` are read as parquet; every other suffix is\n read as CSV. The required columns must be integer-valued, cover exactly the\n target-user set, contain 100 rows and ranks 1 through 100 per user, avoid\n duplicate user-item pairs, and contain only cutoff-eligible items.\n\n Args:\n path: Ranking file to read.\n eligibility: Validation-cutoff candidate membership service.\n targets: Exact set of users the ranking must cover.\n\n Returns:\n A ``uid -> ranked item IDs`` mapping ordered by ascending rank.\n\n Raises:\n ValueError: If the ranking violates the required schema or invariants.\n \"\"\"\n frame = validate_ranking(read_ranking(path), targets)\n if not all(\n eligibility.is_eligible(uid, item)\n for uid, item in frame[[\"uid\", \"item_id\"]].itertuples(index=False, name=None)\n ):\n raise RankingValidationError(\n \"submission contains an item rejected by eligibility service\"\n )\n return ranked_items(frame)\n\n\ndef score(\n ranked: dict[int, list[int]],\n graded: dict[int, dict[int, int]],\n) -> dict[str, float | int]:\n \"\"\"Aggregate per-user NDCG@10 over users with public relevance labels.\n\n Args:\n ranked: Ranked item IDs for every target user.\n graded: Eligible validation relevance keyed by user and item.\n\n Returns:\n The six-decimal ``quality_ndcg@10`` value and number of scored users.\n \"\"\"\n return score_rankings(ranked, graded)\n\n\ndef main() -> None:\n \"\"\"Run the public evaluator CLI and print its JSON score report.\"\"\"\n targets_frame = pd.read_parquet(DATA / \"target_users.parquet\")\n targets = set(targets_frame.uid.astype(int))\n eligibility = CandidateSet(DATA / \"validation_eligible_candidates.npz\")\n graded = validation_truth(eligibility, targets)\n\n if len(sys.argv) != 2:\n raise SystemExit(\n \"usage: evaluate_public.py \"\n )\n path = Path(sys.argv[1])\n ranked = load_submission(path, eligibility, targets)\n print(json.dumps({\"model\": str(path), \"scores\": score(ranked, graded)}, indent=2))\n\n\nif __name__ == \"__main__\":\n main()\n",
"isError": false
},
"responseMessageId": "21f329b8-ddea-4cd6-a5bb-e5a944453fb5"
}
]
},
{
"id": 7,
"role": "agent",
"timestamp": "2026-09-29T05:37:04.132Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:04.132Z",
"callId": "read_file__call_133143",
"name": "read_file",
"input": {
"start_line": 1,
"file_path": "/task/ranking_evaluation.py"
},
"recorded": {
"id": "read_file__call_133143",
"name": "read_file",
"args": {
"start_line": 1,
"file_path": "/task/ranking_evaluation.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_133143",
"name": "read_file",
"response": {
"output": "\"\"\"Shared public primitives for Yambda discovery-ranking evaluation.\n\nBoth the solver-visible validation evaluator and the private submission judge\nimport this module from the generated task's ``public`` directory. It owns the\nstage-independent contract: reading a ranking, validating its shape, converting\nit to per-user rank order, looking up packed candidate eligibility, and\ncomputing graded NDCG@10.\n\nThe module deliberately contains no event-derived labels, private artifact\npaths, or pass thresholds. Each evaluator supplies its own relevance data and\nper-cutoff eligibility checks around these common operations.\n\"\"\"\nfrom __future__ import annotations\n\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\n\n\n__all__ = [\n \"CandidateSet\",\n \"QUALITY_K\",\n \"RankingValidationError\",\n \"REQUIRED_COLUMNS\",\n \"TOP_N\",\n \"ndcg_at_k\",\n \"ranked_items\",\n \"read_ranking\",\n \"score_rankings\",\n \"validate_ranking\",\n]\n\nTOP_N = 100\nQUALITY_K = 10\nREQUIRED_COLUMNS = (\"uid\", \"item_id\", \"rank\")\n\n\nclass RankingValidationError(ValueError):\n \"\"\"Report a ranking-schema or structural-contract violation.\"\"\"\n\n\nclass CandidateSet:\n \"\"\"Provide membership lookups over one packed candidate-set archive.\n\n The archive contains aligned ``uids``, ``item_ids``, and\n ``packed_eligible`` arrays. Candidate column ``c`` is represented by bit\n ``c % 8`` of byte ``c // 8`` using little-endian bit order. Arrays are\n copied into memory so they remain valid after the archive is closed.\n \"\"\"\n\n def __init__(self, path: Path):\n \"\"\"Load an eligibility archive and build ID-to-position indexes.\n\n Args:\n path: Path to a ``.npz`` archive with the candidate-set schema.\n \"\"\"\n with np.load(path, allow_pickle=False) as artifact:\n self.uids = artifact[\"uids\"].astype(np.int64, copy=True)\n self.item_ids = artifact[\"item_ids\"].astype(np.int64, copy=True)\n self.packed = artifact[\"packed_eligible\"].astype(np.uint8, copy=True)\n self.uid_row = {int(uid): row for row, uid in enumerate(self.uids)}\n self.item_column = {\n int(item): column for column, item in enumerate(self.item_ids)\n }\n\n def is_eligible(self, uid: int, item_id: int) -> bool:\n \"\"\"Return whether ``item_id`` is eligible for ``uid``.\n\n IDs absent from the target-user or candidate-item arrays are treated as\n ineligible rather than raising an exception.\n\n Args:\n uid: Target user ID to query.\n item_id: Candidate item ID to query.\n\n Returns:\n ``True`` only when the corresponding packed eligibility bit is set.\n \"\"\"\n row = self.uid_row.get(int(uid))\n column = self.item_column.get(int(item_id))\n if row is None or column is None:\n return False\n byte, bit = divmod(column, 8)\n return bool((int(self.packed[row, byte]) >> bit) & 1)\n\n\ndef read_ranking(path: Path) -> pd.DataFrame:\n \"\"\"Read a parquet or CSV ranking into a pandas frame.\n\n Args:\n path: Input path. A ``.parquet`` suffix selects parquet; every other\n suffix is interpreted as CSV.\n\n Returns:\n The ranking frame as loaded by pandas.\n \"\"\"\n return pd.read_parquet(path) if path.suffix == \".parquet\" else pd.read_csv(path)\n\n\ndef validate_ranking(\n frame: pd.DataFrame,\n targets: set[int],\n) -> pd.DataFrame:\n \"\"\"Normalize and validate the stage-independent ranking contract.\n\n Required values must be finite integers. The user set must exactly match\n ``targets``; every user must have 100 rows, distinct items, and each rank\n from 1 through 100 exactly once. Cutoff-specific candidate eligibility is\n intentionally left to the calling evaluator.\n\n Args:\n frame: Raw ranking frame. Extra columns are discarded from an internal\n copy; the caller's frame is not modified.\n targets: Exact set of target user IDs the ranking must cover.\n\n Returns:\n A normalized frame containing only the required ``int64`` columns.\n\n Raises:\n RankingValidationError: If the ranking violates the shared contract.\n \"\"\"\n required = list(REQUIRED_COLUMNS)\n if not all(column in frame for column in required):\n raise RankingValidationError(f\"submission requires columns {required}\")\n\n normalized = frame[required].copy()\n for column in required:\n numeric = pd.to_numeric(normalized[column], errors=\"coerce\")\n values = numeric.to_numpy(dtype=float)\n if numeric.isna().any() or not np.isfinite(values).all():\n raise RankingValidationError(\n f\"submission {column} must be finite numeric values\"\n )\n if not np.equal(numeric, np.floor(numeric)).all():\n raise RankingValidationError(\n f\"submission {column} must contain integers\"\n )\n normalized[column] = numeric.astype(np.int64)\n\n submitted_users = set(map(int, normalized.uid.unique()))\n if submitted_users != targets:\n raise RankingValidationError(\n f\"submission user set mismatch: missing={len(targets - submitted_users)} \"\n f\"extra={len(submitted_users - targets)}\"\n )\n counts = normalized.groupby(\"uid\").size()\n if not (counts == TOP_N).all():\n raise RankingValidationError(\n f\"submission must contain exactly {TOP_N} rows for every target user\"\n )\n if normalized.duplicated([\"uid\", \"item_id\"]).any():\n raise RankingValidationError(\n \"submission contains duplicate (uid, item_id) pairs\"\n )\n valid_ranks = set(range(1, TOP_N + 1))\n ranks_are_valid = normalized.groupby(\"uid\")[\"rank\"].apply(\n lambda values: set(map(int, values)) == valid_ranks\n )\n if not ranks_are_valid.all():\n raise RankingValidationError(\n f\"each user must have every rank from 1 through {TOP_N} exactly once\"\n )\n return normalized\n\n\ndef ranked_items(frame: pd.DataFrame) -> dict[int, list[int]]:\n \"\"\"Convert a validated ranking frame to ordered items keyed by user.\n\n Args:\n frame: Frame that has passed :func:`validate_ranking`.\n\n Returns:\n A ``uid -> item IDs`` mapping ordered by ascending rank.\n \"\"\"\n ordered = frame.sort_values([\"uid\", \"rank\"])\n return {\n int(uid): list(map(int, values))\n for uid, values in ordered.groupby(\"uid\").item_id\n }\n\n\ndef ndcg_at_k(ranked: list[int], gold: dict[int, int], k: int) -> float:\n \"\"\"Compute graded normalized discounted cumulative gain at ``k``.\n\n Relevance gain is ``2**grade - 1`` and the discount at one-based rank\n ``r`` is ``1 / log2(r + 1)``. Items absent from ``gold`` have grade zero.\n\n Args:\n ranked: Item IDs in predicted rank order.\n gold: Mapping from relevant item IDs to integer relevance grades.\n k: Maximum number of predicted positions to score.\n\n Returns:\n For a valid duplicate-free ranking, NDCG in ``[0, 1]``; returns\n ``0.0`` when the ideal gain is zero.\n \"\"\"\n gains = np.asarray([gold.get(item, 0) for item in ranked[:k]], dtype=np.float64)\n discounts = 1.0 / np.log2(np.arange(2, len(gains) + 2))\n dcg = float(np.sum((np.power(2.0, gains) - 1.0) * discounts))\n ideal = np.asarray(sorted(gold.values(), reverse=True)[:k], dtype=np.float64)\n ideal_discounts = 1.0 / np.log2(np.arange(2, len(ideal) + 2))\n idcg = float(np.sum((np.power(2.0, ideal) - 1.0) * ideal_discounts))\n return dcg / idcg if idcg else 0.0\n\n\ndef score_rankings(\n ranked: dict[int, list[int]],\n graded: dict[int, dict[int, int]],\n) -> dict[str, float | int]:\n \"\"\"Aggregate per-user NDCG@10 over users with relevance labels.\n\n Args:\n ranked: Ranked item IDs for every target user.\n graded: Relevant item grades keyed by user and item.\n\n Returns:\n The six-decimal ``quality_ndcg@10`` value and number of scored users.\n \"\"\"\n quality = float(\n np.mean(\n [\n ndcg_at_k(ranked[uid], gold, QUALITY_K)\n for uid, gold in graded.items()\n ]\n )\n )\n return {\n \"quality_ndcg@10\": round(quality, 6),\n \"quality_users\": len(graded),\n }\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:04.136Z",
"resultDisplay": "",
"description": "../task/ranking_evaluation.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:04.137Z",
"content": "\"\"\"Shared public primitives for Yambda discovery-ranking evaluation.\n\nBoth the solver-visible validation evaluator and the private submission judge\nimport this module from the generated task's ``public`` directory. It owns the\nstage-independent contract: reading a ranking, validating its shape, converting\nit to per-user rank order, looking up packed candidate eligibility, and\ncomputing graded NDCG@10.\n\nThe module deliberately contains no event-derived labels, private artifact\npaths, or pass thresholds. Each evaluator supplies its own relevance data and\nper-cutoff eligibility checks around these common operations.\n\"\"\"\nfrom __future__ import annotations\n\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\n\n\n__all__ = [\n \"CandidateSet\",\n \"QUALITY_K\",\n \"RankingValidationError\",\n \"REQUIRED_COLUMNS\",\n \"TOP_N\",\n \"ndcg_at_k\",\n \"ranked_items\",\n \"read_ranking\",\n \"score_rankings\",\n \"validate_ranking\",\n]\n\nTOP_N = 100\nQUALITY_K = 10\nREQUIRED_COLUMNS = (\"uid\", \"item_id\", \"rank\")\n\n\nclass RankingValidationError(ValueError):\n \"\"\"Report a ranking-schema or structural-contract violation.\"\"\"\n\n\nclass CandidateSet:\n \"\"\"Provide membership lookups over one packed candidate-set archive.\n\n The archive contains aligned ``uids``, ``item_ids``, and\n ``packed_eligible`` arrays. Candidate column ``c`` is represented by bit\n ``c % 8`` of byte ``c // 8`` using little-endian bit order. Arrays are\n copied into memory so they remain valid after the archive is closed.\n \"\"\"\n\n def __init__(self, path: Path):\n \"\"\"Load an eligibility archive and build ID-to-position indexes.\n\n Args:\n path: Path to a ``.npz`` archive with the candidate-set schema.\n \"\"\"\n with np.load(path, allow_pickle=False) as artifact:\n self.uids = artifact[\"uids\"].astype(np.int64, copy=True)\n self.item_ids = artifact[\"item_ids\"].astype(np.int64, copy=True)\n self.packed = artifact[\"packed_eligible\"].astype(np.uint8, copy=True)\n self.uid_row = {int(uid): row for row, uid in enumerate(self.uids)}\n self.item_column = {\n int(item): column for column, item in enumerate(self.item_ids)\n }\n\n def is_eligible(self, uid: int, item_id: int) -> bool:\n \"\"\"Return whether ``item_id`` is eligible for ``uid``.\n\n IDs absent from the target-user or candidate-item arrays are treated as\n ineligible rather than raising an exception.\n\n Args:\n uid: Target user ID to query.\n item_id: Candidate item ID to query.\n\n Returns:\n ``True`` only when the corresponding packed eligibility bit is set.\n \"\"\"\n row = self.uid_row.get(int(uid))\n column = self.item_column.get(int(item_id))\n if row is None or column is None:\n return False\n byte, bit = divmod(column, 8)\n return bool((int(self.packed[row, byte]) >> bit) & 1)\n\n\ndef read_ranking(path: Path) -> pd.DataFrame:\n \"\"\"Read a parquet or CSV ranking into a pandas frame.\n\n Args:\n path: Input path. A ``.parquet`` suffix selects parquet; every other\n suffix is interpreted as CSV.\n\n Returns:\n The ranking frame as loaded by pandas.\n \"\"\"\n return pd.read_parquet(path) if path.suffix == \".parquet\" else pd.read_csv(path)\n\n\ndef validate_ranking(\n frame: pd.DataFrame,\n targets: set[int],\n) -> pd.DataFrame:\n \"\"\"Normalize and validate the stage-independent ranking contract.\n\n Required values must be finite integers. The user set must exactly match\n ``targets``; every user must have 100 rows, distinct items, and each rank\n from 1 through 100 exactly once. Cutoff-specific candidate eligibility is\n intentionally left to the calling evaluator.\n\n Args:\n frame: Raw ranking frame. Extra columns are discarded from an internal\n copy; the caller's frame is not modified.\n targets: Exact set of target user IDs the ranking must cover.\n\n Returns:\n A normalized frame containing only the required ``int64`` columns.\n\n Raises:\n RankingValidationError: If the ranking violates the shared contract.\n \"\"\"\n required = list(REQUIRED_COLUMNS)\n if not all(column in frame for column in required):\n raise RankingValidationError(f\"submission requires columns {required}\")\n\n normalized = frame[required].copy()\n for column in required:\n numeric = pd.to_numeric(normalized[column], errors=\"coerce\")\n values = numeric.to_numpy(dtype=float)\n if numeric.isna().any() or not np.isfinite(values).all():\n raise RankingValidationError(\n f\"submission {column} must be finite numeric values\"\n )\n if not np.equal(numeric, np.floor(numeric)).all():\n raise RankingValidationError(\n f\"submission {column} must contain integers\"\n )\n normalized[column] = numeric.astype(np.int64)\n\n submitted_users = set(map(int, normalized.uid.unique()))\n if submitted_users != targets:\n raise RankingValidationError(\n f\"submission user set mismatch: missing={len(targets - submitted_users)} \"\n f\"extra={len(submitted_users - targets)}\"\n )\n counts = normalized.groupby(\"uid\").size()\n if not (counts == TOP_N).all():\n raise RankingValidationError(\n f\"submission must contain exactly {TOP_N} rows for every target user\"\n )\n if normalized.duplicated([\"uid\", \"item_id\"]).any():\n raise RankingValidationError(\n \"submission contains duplicate (uid, item_id) pairs\"\n )\n valid_ranks = set(range(1, TOP_N + 1))\n ranks_are_valid = normalized.groupby(\"uid\")[\"rank\"].apply(\n lambda values: set(map(int, values)) == valid_ranks\n )\n if not ranks_are_valid.all():\n raise RankingValidationError(\n f\"each user must have every rank from 1 through {TOP_N} exactly once\"\n )\n return normalized\n\n\ndef ranked_items(frame: pd.DataFrame) -> dict[int, list[int]]:\n \"\"\"Convert a validated ranking frame to ordered items keyed by user.\n\n Args:\n frame: Frame that has passed :func:`validate_ranking`.\n\n Returns:\n A ``uid -> item IDs`` mapping ordered by ascending rank.\n \"\"\"\n ordered = frame.sort_values([\"uid\", \"rank\"])\n return {\n int(uid): list(map(int, values))\n for uid, values in ordered.groupby(\"uid\").item_id\n }\n\n\ndef ndcg_at_k(ranked: list[int], gold: dict[int, int], k: int) -> float:\n \"\"\"Compute graded normalized discounted cumulative gain at ``k``.\n\n Relevance gain is ``2**grade - 1`` and the discount at one-based rank\n ``r`` is ``1 / log2(r + 1)``. Items absent from ``gold`` have grade zero.\n\n Args:\n ranked: Item IDs in predicted rank order.\n gold: Mapping from relevant item IDs to integer relevance grades.\n k: Maximum number of predicted positions to score.\n\n Returns:\n For a valid duplicate-free ranking, NDCG in ``[0, 1]``; returns\n ``0.0`` when the ideal gain is zero.\n \"\"\"\n gains = np.asarray([gold.get(item, 0) for item in ranked[:k]], dtype=np.float64)\n discounts = 1.0 / np.log2(np.arange(2, len(gains) + 2))\n dcg = float(np.sum((np.power(2.0, gains) - 1.0) * discounts))\n ideal = np.asarray(sorted(gold.values(), reverse=True)[:k], dtype=np.float64)\n ideal_discounts = 1.0 / np.log2(np.arange(2, len(ideal) + 2))\n idcg = float(np.sum((np.power(2.0, ideal) - 1.0) * ideal_discounts))\n return dcg / idcg if idcg else 0.0\n\n\ndef score_rankings(\n ranked: dict[int, list[int]],\n graded: dict[int, dict[int, int]],\n) -> dict[str, float | int]:\n \"\"\"Aggregate per-user NDCG@10 over users with relevance labels.\n\n Args:\n ranked: Ranked item IDs for every target user.\n graded: Relevant item grades keyed by user and item.\n\n Returns:\n The six-decimal ``quality_ndcg@10`` value and number of scored users.\n \"\"\"\n quality = float(\n np.mean(\n [\n ndcg_at_k(ranked[uid], gold, QUALITY_K)\n for uid, gold in graded.items()\n ]\n )\n )\n return {\n \"quality_ndcg@10\": round(quality, 6),\n \"quality_users\": len(graded),\n }\n",
"isError": false
},
"responseMessageId": "f91b1ace-86d9-4081-9771-4a64e1080834"
}
]
},
{
"id": 8,
"role": "agent",
"timestamp": "2026-09-29T05:37:05.924Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:05.924Z",
"callId": "read_file__call_29433",
"name": "read_file",
"input": {
"file_path": "/task/current_model/two_tower_model.py",
"start_line": 1,
"end_line": 200
},
"recorded": {
"id": "read_file__call_29433",
"name": "read_file",
"args": {
"file_path": "/task/current_model/two_tower_model.py",
"start_line": 1,
"end_line": 200
},
"result": [
{
"functionResponse": {
"id": "read_file__call_29433",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1-200 of 434 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 201.\n\n--- FILE CONTENT (truncated) ---\n\"\"\"Shared public-data primitives for the Yambda two-tower baseline.\"\"\"\nfrom __future__ import annotations\n\nimport sys\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Iterator\n\nimport numpy as np\nimport pandas as pd\nimport pyarrow.parquet as pq\nimport torch\nfrom torch import nn\n\n\nDAY = 86_400\nTRAIN_END = 24_786_800\nVALIDATION_END = 25_393_400\nLISTEN_POSITIVE_THRESHOLD = 50\nPROFILE_LOOKBACK_DAYS = 120\nLIKE_ITEMS = 48\nDISLIKE_ITEMS = 24\nTOP_N = 100\n\n\n@dataclass(frozen=True)\nclass TowerConfig:\n sequence_length: int = 100\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass ListenEvents:\n timestamps: np.ndarray\n items: np.ndarray\n organic: np.ndarray\n completion_pct: np.ndarray\n\n\n@dataclass(frozen=True)\nclass ExplicitEvents:\n timestamps: np.ndarray\n items: np.ndarray\n channel: np.ndarray\n active: np.ndarray\n organic_like: np.ndarray\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef build_item_features(catalog: pd.DataFrame) -> np.ndarray:\n \"\"\"Return four standardized features built only from the public catalog.\"\"\"\n positives = catalog.positive_listens.to_numpy(dtype=np.float64, copy=False)\n organic = catalog.organic_positive_listens.to_numpy(dtype=np.float64, copy=False)\n popularity_rank = catalog.popularity_rank.to_numpy(dtype=np.float64, copy=False)\n features = np.column_stack(\n [\n np.log1p(positives),\n np.log1p(organic),\n organic / np.maximum(positives, 1.0),\n 1.0 - (popularity_rank - 1.0) / max(len(catalog) - 1, 1),\n ]\n )\n means = features.mean(axis=0, keepdims=True)\n scales = np.maximum(features.std(axis=0, keepdims=True), 1.0e-6)\n standardized = ((features - means) / scales).astype(np.float32)\n if not np.isfinite(standardized).all():\n raise RuntimeError(\"catalog features contain non-finite values\")\n return standardized\n\n\ndef _combine_listen_chunks(parts: list[ListenEvents]) -> ListenEvents:\n if len(parts) == 1:\n return parts[0]\n timestamps = np.concatenate([part.timestamps for part in parts])\n items = np.concatenate([part.items for part in parts])\n organic = np.concatenate([part.organic for part in parts])\n completion = np.concatenate([part.completion_pct for part in parts])\n order = np.argsort(timestamps, kind=\"stable\")\n return ListenEvents(\n timestamps=timestamps[order],\n items=items[order],\n organic=organic[order],\n completion_pct=completion[order],\n )\n\n\ndef iter_listen_users(\n path: Path, item_index: pd.Index\n) -> Iterator[tuple[int, ListenEvents]]:\n \"\"\"Stream one uid-sorted public listen file one user at a time.\"\"\"\n parquet = pq.ParquetFile(path)\n pending_uid: int | None = None\n pending: list[ListenEvents] = []\n previous_uid = -1\n for batch in parquet.iter_batches(\n batch_size=750_000,\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\", \"played_ratio_pct\"],\n ):\n frame = batch.to_pandas()\n mapped = item_index.get_indexer(frame.item_id.to_numpy(dtype=np.int64))\n keep = mapped >= 0\n if not np.any(keep):\n continue\n uids = frame.uid.to_numpy(dtype=np.int64, copy=False)[keep]\n timestamps = frame.timestamp.to_numpy(dtype=np.int64, copy=False)[keep]\n items = mapped[keep].astype(np.int32, copy=False)\n organic = frame.is_organic.to_numpy(dtype=np.uint8, copy=False)[keep]\n completion = frame.played_ratio_pct.to_numpy(dtype=np.uint16, copy=False)[keep]\n if np.any(uids[1:] < uids[:-1]):\n raise RuntimeError(f\"{path.name} is not sorted by uid\")\n boundaries = np.r_[\n 0,\n np.flatnonzero(uids[1:] != uids[:-1]) + 1,\n len(uids),\n ]\n for start, end in zip(boundaries[:-1], boundaries[1:]):\n uid = int(uids[start])\n part = ListenEvents(\n timestamps[start:end].copy(),\n items[start:end].copy(),\n organic[start:end].copy(),\n completion[start:end].copy(),\n )\n if pending_uid is None:\n pending_uid = uid\n elif uid != pending_uid:\n if pending_uid < previous_uid:\n raise RuntimeError(f\"{path.name} user order regressed\")\n yield pending_uid, _combine_listen_chunks(pending)\n previous_uid = pending_uid\n pending_uid = uid\n pending = []\n pending.append(part)\n if pending_uid is not None:\n yield pending_uid, _combine_listen_chunks(pending)\n\n\ndef merge_listen_streams(\n paths: list[Path], item_index: pd.Index\n) -> Iterator[tuple[int, ListenEvents]]:\n \"\"\"Merge uid-sorted public listen files without materializing them.\"\"\"\n streams = [iter(iter_listen_users(path, item_index)) for path in paths]\n heads: list[tuple[int, ListenEvents] | None] = [\n next(stream, None) for stream in streams\n ]\n while any(head is not None for head in heads):\n uid = min(head[0] for head in heads if head is not None)\n parts: list[ListenEvents] = []\n for position, head in enumerate(heads):\n if head is not None and head[0] == uid:\n parts.append(head[1])\n heads[position] = next(streams[position], None)\n yield uid, _combine_listen_chunks(parts)\n\n\ndef load_explicit_events(\n data: Path,\n prefixes: tuple[str, ...],\n item_index: pd.Index,\n) -> dict[int, ExplicitEvents]:\n \"\"\"Load public explicit actions as chronological state changes.\"\"\"\n specifications = (\n (\"likes\", 0, 1, 0),\n (\"unlikes\", 0, 0, 1),\n (\"dislikes\", 1, 1, 0),\n (\"undislikes\", 1, 0, 1),\n )\n parts: list[pd.DataFrame] = []\n for family, channel, active, tie_priority in specifications:\n for prefix in prefixes:\n frame = pd.read_parquet(\n data / f\"{prefix}_{family}.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n mapped = item_index.get_indexer(\n frame.item_id.to_numpy(dtype=np.int64, copy=False)\n )\n keep = mapped >= 0\n if not np.any(keep):\n continue\n retained = frame.loc[keep, [\"uid\", \"timestamp\", \"is_organic\"]].copy()"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:05.927Z",
"resultDisplay": "Read lines 1-200 of 434 from ../task/current_model/two_tower_model.py",
"description": "../.../two_tower_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:05.928Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1-200 of 434 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 201.\n\n--- FILE CONTENT (truncated) ---\n\"\"\"Shared public-data primitives for the Yambda two-tower baseline.\"\"\"\nfrom __future__ import annotations\n\nimport sys\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import Iterator\n\nimport numpy as np\nimport pandas as pd\nimport pyarrow.parquet as pq\nimport torch\nfrom torch import nn\n\n\nDAY = 86_400\nTRAIN_END = 24_786_800\nVALIDATION_END = 25_393_400\nLISTEN_POSITIVE_THRESHOLD = 50\nPROFILE_LOOKBACK_DAYS = 120\nLIKE_ITEMS = 48\nDISLIKE_ITEMS = 24\nTOP_N = 100\n\n\n@dataclass(frozen=True)\nclass TowerConfig:\n sequence_length: int = 100\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass ListenEvents:\n timestamps: np.ndarray\n items: np.ndarray\n organic: np.ndarray\n completion_pct: np.ndarray\n\n\n@dataclass(frozen=True)\nclass ExplicitEvents:\n timestamps: np.ndarray\n items: np.ndarray\n channel: np.ndarray\n active: np.ndarray\n organic_like: np.ndarray\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef build_item_features(catalog: pd.DataFrame) -> np.ndarray:\n \"\"\"Return four standardized features built only from the public catalog.\"\"\"\n positives = catalog.positive_listens.to_numpy(dtype=np.float64, copy=False)\n organic = catalog.organic_positive_listens.to_numpy(dtype=np.float64, copy=False)\n popularity_rank = catalog.popularity_rank.to_numpy(dtype=np.float64, copy=False)\n features = np.column_stack(\n [\n np.log1p(positives),\n np.log1p(organic),\n organic / np.maximum(positives, 1.0),\n 1.0 - (popularity_rank - 1.0) / max(len(catalog) - 1, 1),\n ]\n )\n means = features.mean(axis=0, keepdims=True)\n scales = np.maximum(features.std(axis=0, keepdims=True), 1.0e-6)\n standardized = ((features - means) / scales).astype(np.float32)\n if not np.isfinite(standardized).all():\n raise RuntimeError(\"catalog features contain non-finite values\")\n return standardized\n\n\ndef _combine_listen_chunks(parts: list[ListenEvents]) -> ListenEvents:\n if len(parts) == 1:\n return parts[0]\n timestamps = np.concatenate([part.timestamps for part in parts])\n items = np.concatenate([part.items for part in parts])\n organic = np.concatenate([part.organic for part in parts])\n completion = np.concatenate([part.completion_pct for part in parts])\n order = np.argsort(timestamps, kind=\"stable\")\n return ListenEvents(\n timestamps=timestamps[order],\n items=items[order],\n organic=organic[order],\n completion_pct=completion[order],\n )\n\n\ndef iter_listen_users(\n path: Path, item_index: pd.Index\n) -> Iterator[tuple[int, ListenEvents]]:\n \"\"\"Stream one uid-sorted public listen file one user at a time.\"\"\"\n parquet = pq.ParquetFile(path)\n pending_uid: int | None = None\n pending: list[ListenEvents] = []\n previous_uid = -1\n for batch in parquet.iter_batches(\n batch_size=750_000,\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\", \"played_ratio_pct\"],\n ):\n frame = batch.to_pandas()\n mapped = item_index.get_indexer(frame.item_id.to_numpy(dtype=np.int64))\n keep = mapped >= 0\n if not np.any(keep):\n continue\n uids = frame.uid.to_numpy(dtype=np.int64, copy=False)[keep]\n timestamps = frame.timestamp.to_numpy(dtype=np.int64, copy=False)[keep]\n items = mapped[keep].astype(np.int32, copy=False)\n organic = frame.is_organic.to_numpy(dtype=np.uint8, copy=False)[keep]\n completion = frame.played_ratio_pct.to_numpy(dtype=np.uint16, copy=False)[keep]\n if np.any(uids[1:] < uids[:-1]):\n raise RuntimeError(f\"{path.name} is not sorted by uid\")\n boundaries = np.r_[\n 0,\n np.flatnonzero(uids[1:] != uids[:-1]) + 1,\n len(uids),\n ]\n for start, end in zip(boundaries[:-1], boundaries[1:]):\n uid = int(uids[start])\n part = ListenEvents(\n timestamps[start:end].copy(),\n items[start:end].copy(),\n organic[start:end].copy(),\n completion[start:end].copy(),\n )\n if pending_uid is None:\n pending_uid = uid\n elif uid != pending_uid:\n if pending_uid < previous_uid:\n raise RuntimeError(f\"{path.name} user order regressed\")\n yield pending_uid, _combine_listen_chunks(pending)\n previous_uid = pending_uid\n pending_uid = uid\n pending = []\n pending.append(part)\n if pending_uid is not None:\n yield pending_uid, _combine_listen_chunks(pending)\n\n\ndef merge_listen_streams(\n paths: list[Path], item_index: pd.Index\n) -> Iterator[tuple[int, ListenEvents]]:\n \"\"\"Merge uid-sorted public listen files without materializing them.\"\"\"\n streams = [iter(iter_listen_users(path, item_index)) for path in paths]\n heads: list[tuple[int, ListenEvents] | None] = [\n next(stream, None) for stream in streams\n ]\n while any(head is not None for head in heads):\n uid = min(head[0] for head in heads if head is not None)\n parts: list[ListenEvents] = []\n for position, head in enumerate(heads):\n if head is not None and head[0] == uid:\n parts.append(head[1])\n heads[position] = next(streams[position], None)\n yield uid, _combine_listen_chunks(parts)\n\n\ndef load_explicit_events(\n data: Path,\n prefixes: tuple[str, ...],\n item_index: pd.Index,\n) -> dict[int, ExplicitEvents]:\n \"\"\"Load public explicit actions as chronological state changes.\"\"\"\n specifications = (\n (\"likes\", 0, 1, 0),\n (\"unlikes\", 0, 0, 1),\n (\"dislikes\", 1, 1, 0),\n (\"undislikes\", 1, 0, 1),\n )\n parts: list[pd.DataFrame] = []\n for family, channel, active, tie_priority in specifications:\n for prefix in prefixes:\n frame = pd.read_parquet(\n data / f\"{prefix}_{family}.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n mapped = item_index.get_indexer(\n frame.item_id.to_numpy(dtype=np.int64, copy=False)\n )\n keep = mapped >= 0\n if not np.any(keep):\n continue\n retained = frame.loc[keep, [\"uid\", \"timestamp\", \"is_organic\"]].copy()",
"isError": false
},
"responseMessageId": "72761cd6-ad7b-464c-84a3-417a4c58cefb"
}
]
},
{
"id": 9,
"role": "agent",
"timestamp": "2026-09-29T05:37:08.257Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:08.257Z",
"callId": "read_file__call_152860",
"name": "read_file",
"input": {
"file_path": "/task/current_model/two_tower_model.py",
"start_line": 201,
"end_line": 434
},
"recorded": {
"id": "read_file__call_152860",
"name": "read_file",
"args": {
"file_path": "/task/current_model/two_tower_model.py",
"start_line": 201,
"end_line": 434
},
"result": [
{
"functionResponse": {
"id": "read_file__call_152860",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 201-434 of 434 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 435.\n\n--- FILE CONTENT (truncated) ---\n retained[\"item\"] = mapped[keep].astype(np.int32, copy=False)\n retained[\"channel\"] = np.int8(channel)\n retained[\"active\"] = np.int8(active)\n retained[\"tie_priority\"] = np.int8(tie_priority)\n retained[\"organic_like\"] = np.int8(\n family == \"likes\"\n ) * retained.is_organic.astype(np.int8)\n parts.append(retained.drop(columns=\"is_organic\"))\n if not parts:\n return {}\n events = pd.concat(parts, ignore_index=True)\n events = events.sort_values(\n [\"uid\", \"timestamp\", \"tie_priority\"], kind=\"mergesort\"\n ).reset_index(drop=True)\n result: dict[int, ExplicitEvents] = {}\n for uid, rows in events.groupby(\"uid\", sort=False):\n result[int(uid)] = ExplicitEvents(\n timestamps=rows.timestamp.to_numpy(dtype=np.int64, copy=True),\n items=rows.item.to_numpy(dtype=np.int32, copy=True),\n channel=rows.channel.to_numpy(dtype=np.int8, copy=True),\n active=rows.active.to_numpy(dtype=np.int8, copy=True),\n organic_like=rows.organic_like.to_numpy(dtype=np.int8, copy=True),\n )\n log(f\"loaded explicit events: rows={len(events):,} users={len(result):,}\")\n return result\n\n\ndef empty_explicit_events() -> ExplicitEvents:\n return ExplicitEvents(\n timestamps=np.empty(0, dtype=np.int64),\n items=np.empty(0, dtype=np.int32),\n channel=np.empty(0, dtype=np.int8),\n active=np.empty(0, dtype=np.int8),\n organic_like=np.empty(0, dtype=np.int8),\n )\n\n\ndef pack_active_items(\n active: dict[int, int], width: int, padding_item: int\n) -> np.ndarray:\n packed = np.full(width, padding_item, dtype=np.uint16)\n if not active:\n return packed\n ordered = sorted(active.items(), key=lambda pair: (-pair[1], pair[0]))[:width]\n packed[: len(ordered)] = np.fromiter(\n (item for item, _ in ordered), dtype=np.uint16, count=len(ordered)\n )\n return packed\n\n\ndef load_inference_state(\n path: Path,\n item_index: pd.Index,\n uids: np.ndarray,\n n_items: int,\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\n \"\"\"Pack the task-provided active explicit state.\"\"\"\n state = pd.read_parquet(path, columns=[\"uid\", \"item_id\", \"state\"])\n mapped = item_index.get_indexer(state.item_id.to_numpy(dtype=np.int64))\n keep = mapped >= 0\n state = state.loc[keep, [\"uid\", \"state\"]].copy()\n state[\"item\"] = mapped[keep].astype(np.int32, copy=False)\n user_rows = pd.Index(uids)\n liked = np.full((len(uids), LIKE_ITEMS), n_items, dtype=np.uint16)\n disliked = np.full((len(uids), DISLIKE_ITEMS), n_items, dtype=np.uint16)\n like_counts = np.zeros(len(uids), dtype=np.int32)\n dislike_counts = np.zeros(len(uids), dtype=np.int32)\n for value, width, destination, counts in (\n (\"liked\", LIKE_ITEMS, liked, like_counts),\n (\"disliked\", DISLIKE_ITEMS, disliked, dislike_counts),\n ):\n selected = state[state.state == value]\n for uid, rows in selected.groupby(\"uid\", sort=False):\n row = int(user_rows.get_indexer([int(uid)])[0])\n if row < 0:\n continue\n items = np.sort(rows.item.unique())\n counts[row] = len(items)\n retained = items[:width]\n destination[row, : len(retained)] = retained.astype(np.uint16)\n return liked, disliked, like_counts, dislike_counts\n\n\nclass SequentialTwoTower(nn.Module):\n \"\"\"Order-sensitive user tower and independent catalog-aware item tower.\"\"\"\n\n def __init__(self, item_features: np.ndarray, config: TowerConfig) -> None:\n super().__init__()\n n_items, n_item_features = item_features.shape\n dim = config.embedding_dim\n self.n_items = n_items\n self.context_embedding = nn.Embedding(\n n_items + 1, dim, padding_idx=n_items\n )\n self.event_projection = nn.Sequential(\n nn.Linear(dim + 3, config.hidden_dim),\n nn.GELU(),\n )\n self.sequence_encoder = nn.GRU(\n input_size=config.hidden_dim,\n hidden_size=dim,\n num_layers=1,\n batch_first=True,\n )\n self.user_tower = nn.Sequential(\n nn.Linear(dim * 3 + 6, config.user_hidden_1),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.user_hidden_1, config.user_hidden_2),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.user_hidden_2, dim),\n )\n self.candidate_embedding = nn.Embedding(n_items, dim)\n self.register_buffer(\n \"item_features\", torch.from_numpy(item_features), persistent=True\n )\n self.item_tower = nn.Sequential(\n nn.Linear(dim + n_item_features, config.item_hidden_1),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.item_hidden_1, config.item_hidden_2),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.item_hidden_2, dim),\n )\n nn.init.normal_(self.context_embedding.weight, std=0.02)\n nn.init.normal_(self.candidate_embedding.weight, std=0.02)\n with torch.no_grad():\n self.context_embedding.weight[n_items].zero_()\n\n def _mean_context_channel(self, items: torch.Tensor) -> torch.Tensor:\n mask = items.ne(self.n_items)\n vectors = self.context_embedding(items)\n return (vectors * mask.unsqueeze(-1)).sum(dim=1) / mask.sum(\n dim=1, keepdim=True\n ).clamp_min(1)\n\n def encode_items(self, items: torch.Tensor) -> torch.Tensor:\n inputs = torch.cat(\n [self.candidate_embedding(items), self.item_features[items]], dim=1\n )\n return self.item_tower(inputs)\n\n\ndef invalid_negative_mask(\n negatives: torch.Tensor,\n targets: torch.Tensor,\n context_items: torch.Tensor,\n liked_items: torch.Tensor,\n) -> torch.Tensor:\n \"\"\"Identify targets, known positives, active likes, and row duplicates.\"\"\"\n invalid = negatives.eq(targets[:, None])\n invalid |= negatives[:, :, None].eq(context_items[:, None, :]).any(dim=2)\n invalid |= negatives[:, :, None].eq(liked_items[:, None, :]).any(dim=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= negatives[:, column, None].eq(\n negatives[:, :column]\n ).any(dim=1)\n return invalid\n\n\ndef draw_filtered_mixed_negatives(\n targets: torch.Tensor,\n context_items: torch.Tensor,\n liked_items: torch.Tensor,\n n_items: int,\n uniform_count: int,\n inbatch_count: int,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw uniform and unique-target in-batch negatives.\"\"\"\n batch_size = len(targets)\n uniform = torch.randint(\n n_items,\n (batch_size, uniform_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long, device=\"cpu\")\n corrected_count = 0\n if inbatch_count:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(inbatch_count, max(len(unique_targets) - 1, 0))\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(targets.detach().cpu()[:, None]),\n -1.0,\n )\n columns = torch.topk(priorities, k=corrected_count, dim=1).indices\n inbatch = unique_targets[columns]\n if corrected_count < inbatch_count:\n filler = torch.randint(\n n_items,\n (batch_size, inbatch_count - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives_cpu = torch.cat([uniform, inbatch], dim=1)\n correction_cpu = torch.ones_like(negatives_cpu, dtype=torch.float32)\n if corrected_count:\n correction_cpu[\n :, uniform_count : uniform_count + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]]\n negatives = negatives_cpu.to(device)\n correction = correction_cpu.to(device)\n for _ in range(32):\n invalid = invalid_negative_mask(\n negatives, targets, context_items, liked_items\n )\n if not bool(invalid.any()):\n return negatives, correction\n replacements = torch.randint(\n n_items,\n (int(invalid.sum().detach().cpu()),),\n generator=generator,\n device=\"cpu\",\n ).to(device)\n negatives[invalid] = replacements\n correction[invalid] = 1.0\n invalid = invalid_negative_mask(\n negatives, targets, context_items, liked_items\n )\n if bool(invalid.any()):\n raise RuntimeError(\"mixed negative resampling failed false-negative filter\")\n return negatives, correction\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:08.260Z",
"resultDisplay": "Read lines 201-434 of 434 from ../task/current_model/two_tower_model.py",
"description": "../.../two_tower_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:08.261Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 201-434 of 434 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 435.\n\n--- FILE CONTENT (truncated) ---\n retained[\"item\"] = mapped[keep].astype(np.int32, copy=False)\n retained[\"channel\"] = np.int8(channel)\n retained[\"active\"] = np.int8(active)\n retained[\"tie_priority\"] = np.int8(tie_priority)\n retained[\"organic_like\"] = np.int8(\n family == \"likes\"\n ) * retained.is_organic.astype(np.int8)\n parts.append(retained.drop(columns=\"is_organic\"))\n if not parts:\n return {}\n events = pd.concat(parts, ignore_index=True)\n events = events.sort_values(\n [\"uid\", \"timestamp\", \"tie_priority\"], kind=\"mergesort\"\n ).reset_index(drop=True)\n result: dict[int, ExplicitEvents] = {}\n for uid, rows in events.groupby(\"uid\", sort=False):\n result[int(uid)] = ExplicitEvents(\n timestamps=rows.timestamp.to_numpy(dtype=np.int64, copy=True),\n items=rows.item.to_numpy(dtype=np.int32, copy=True),\n channel=rows.channel.to_numpy(dtype=np.int8, copy=True),\n active=rows.active.to_numpy(dtype=np.int8, copy=True),\n organic_like=rows.organic_like.to_numpy(dtype=np.int8, copy=True),\n )\n log(f\"loaded explicit events: rows={len(events):,} users={len(result):,}\")\n return result\n\n\ndef empty_explicit_events() -> ExplicitEvents:\n return ExplicitEvents(\n timestamps=np.empty(0, dtype=np.int64),\n items=np.empty(0, dtype=np.int32),\n channel=np.empty(0, dtype=np.int8),\n active=np.empty(0, dtype=np.int8),\n organic_like=np.empty(0, dtype=np.int8),\n )\n\n\ndef pack_active_items(\n active: dict[int, int], width: int, padding_item: int\n) -> np.ndarray:\n packed = np.full(width, padding_item, dtype=np.uint16)\n if not active:\n return packed\n ordered = sorted(active.items(), key=lambda pair: (-pair[1], pair[0]))[:width]\n packed[: len(ordered)] = np.fromiter(\n (item for item, _ in ordered), dtype=np.uint16, count=len(ordered)\n )\n return packed\n\n\ndef load_inference_state(\n path: Path,\n item_index: pd.Index,\n uids: np.ndarray,\n n_items: int,\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:\n \"\"\"Pack the task-provided active explicit state.\"\"\"\n state = pd.read_parquet(path, columns=[\"uid\", \"item_id\", \"state\"])\n mapped = item_index.get_indexer(state.item_id.to_numpy(dtype=np.int64))\n keep = mapped >= 0\n state = state.loc[keep, [\"uid\", \"state\"]].copy()\n state[\"item\"] = mapped[keep].astype(np.int32, copy=False)\n user_rows = pd.Index(uids)\n liked = np.full((len(uids), LIKE_ITEMS), n_items, dtype=np.uint16)\n disliked = np.full((len(uids), DISLIKE_ITEMS), n_items, dtype=np.uint16)\n like_counts = np.zeros(len(uids), dtype=np.int32)\n dislike_counts = np.zeros(len(uids), dtype=np.int32)\n for value, width, destination, counts in (\n (\"liked\", LIKE_ITEMS, liked, like_counts),\n (\"disliked\", DISLIKE_ITEMS, disliked, dislike_counts),\n ):\n selected = state[state.state == value]\n for uid, rows in selected.groupby(\"uid\", sort=False):\n row = int(user_rows.get_indexer([int(uid)])[0])\n if row < 0:\n continue\n items = np.sort(rows.item.unique())\n counts[row] = len(items)\n retained = items[:width]\n destination[row, : len(retained)] = retained.astype(np.uint16)\n return liked, disliked, like_counts, dislike_counts\n\n\nclass SequentialTwoTower(nn.Module):\n \"\"\"Order-sensitive user tower and independent catalog-aware item tower.\"\"\"\n\n def __init__(self, item_features: np.ndarray, config: TowerConfig) -> None:\n super().__init__()\n n_items, n_item_features = item_features.shape\n dim = config.embedding_dim\n self.n_items = n_items\n self.context_embedding = nn.Embedding(\n n_items + 1, dim, padding_idx=n_items\n )\n self.event_projection = nn.Sequential(\n nn.Linear(dim + 3, config.hidden_dim),\n nn.GELU(),\n )\n self.sequence_encoder = nn.GRU(\n input_size=config.hidden_dim,\n hidden_size=dim,\n num_layers=1,\n batch_first=True,\n )\n self.user_tower = nn.Sequential(\n nn.Linear(dim * 3 + 6, config.user_hidden_1),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.user_hidden_1, config.user_hidden_2),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.user_hidden_2, dim),\n )\n self.candidate_embedding = nn.Embedding(n_items, dim)\n self.register_buffer(\n \"item_features\", torch.from_numpy(item_features), persistent=True\n )\n self.item_tower = nn.Sequential(\n nn.Linear(dim + n_item_features, config.item_hidden_1),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.item_hidden_1, config.item_hidden_2),\n nn.GELU(),\n nn.Dropout(config.dropout),\n nn.Linear(config.item_hidden_2, dim),\n )\n nn.init.normal_(self.context_embedding.weight, std=0.02)\n nn.init.normal_(self.candidate_embedding.weight, std=0.02)\n with torch.no_grad():\n self.context_embedding.weight[n_items].zero_()\n\n def _mean_context_channel(self, items: torch.Tensor) -> torch.Tensor:\n mask = items.ne(self.n_items)\n vectors = self.context_embedding(items)\n return (vectors * mask.unsqueeze(-1)).sum(dim=1) / mask.sum(\n dim=1, keepdim=True\n ).clamp_min(1)\n\n def encode_items(self, items: torch.Tensor) -> torch.Tensor:\n inputs = torch.cat(\n [self.candidate_embedding(items), self.item_features[items]], dim=1\n )\n return self.item_tower(inputs)\n\n\ndef invalid_negative_mask(\n negatives: torch.Tensor,\n targets: torch.Tensor,\n context_items: torch.Tensor,\n liked_items: torch.Tensor,\n) -> torch.Tensor:\n \"\"\"Identify targets, known positives, active likes, and row duplicates.\"\"\"\n invalid = negatives.eq(targets[:, None])\n invalid |= negatives[:, :, None].eq(context_items[:, None, :]).any(dim=2)\n invalid |= negatives[:, :, None].eq(liked_items[:, None, :]).any(dim=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= negatives[:, column, None].eq(\n negatives[:, :column]\n ).any(dim=1)\n return invalid\n\n\ndef draw_filtered_mixed_negatives(\n targets: torch.Tensor,\n context_items: torch.Tensor,\n liked_items: torch.Tensor,\n n_items: int,\n uniform_count: int,\n inbatch_count: int,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw uniform and unique-target in-batch negatives.\"\"\"\n batch_size = len(targets)\n uniform = torch.randint(\n n_items,\n (batch_size, uniform_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long, device=\"cpu\")\n corrected_count = 0\n if inbatch_count:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(inbatch_count, max(len(unique_targets) - 1, 0))\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(targets.detach().cpu()[:, None]),\n -1.0,\n )\n columns = torch.topk(priorities, k=corrected_count, dim=1).indices\n inbatch = unique_targets[columns]\n if corrected_count < inbatch_count:\n filler = torch.randint(\n n_items,\n (batch_size, inbatch_count - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives_cpu = torch.cat([uniform, inbatch], dim=1)\n correction_cpu = torch.ones_like(negatives_cpu, dtype=torch.float32)\n if corrected_count:\n correction_cpu[\n :, uniform_count : uniform_count + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]]\n negatives = negatives_cpu.to(device)\n correction = correction_cpu.to(device)\n for _ in range(32):\n invalid = invalid_negative_mask(\n negatives, targets, context_items, liked_items\n )\n if not bool(invalid.any()):\n return negatives, correction\n replacements = torch.randint(\n n_items,\n (int(invalid.sum().detach().cpu()),),\n generator=generator,\n device=\"cpu\",\n ).to(device)\n negatives[invalid] = replacements\n correction[invalid] = 1.0\n invalid = invalid_negative_mask(\n negatives, targets, context_items, liked_items\n )\n if bool(invalid.any()):\n raise RuntimeError(\"mixed negative resampling failed false-negative filter\")\n return negatives, correction\n",
"isError": false
},
"responseMessageId": "32c613a8-8aba-4b12-9545-24949ed36268"
}
]
},
{
"id": 10,
"role": "agent",
"timestamp": "2026-09-29T05:37:10.693Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:37:10.693Z",
"text": "Examining Training Pipeline\n\nI'm currently deep-diving into `draw_filtered_mixed_negatives` and `invalid_negative_mask` functions. My next step is to meticulously review `train_current_model.py` to understand the intricate wiring, loss computation, and evaluation/ranking mechanisms."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:10.693Z",
"callId": "grep_search__call_6053076",
"name": "grep_search",
"input": {
"pattern": "def ",
"dir_path": "/task/current_model"
},
"recorded": {
"id": "grep_search__call_6053076",
"name": "grep_search",
"args": {
"pattern": "def ",
"dir_path": "/task/current_model"
},
"result": [
{
"functionResponse": {
"id": "grep_search__call_6053076",
"name": "grep_search",
"response": {
"output": "Found 57 matches for pattern \"def \" in path \"/task/current_model\":\n---\nFile: train_current_model.py\nL82: def read(cls, path: Path) -> \"CandidateSet\":\nL118: def lengths(self) -> np.ndarray:\nL122: def target_count(self) -> int:\nL136: def selected_count(self) -> int:\nL140: def log(message: str) -> None:\nL144: def seed_everything(seed: int) -> None:\nL150: def model_config(config: Config) -> base.TowerConfig:\nL174: def append_state_snapshot(\nL190: def causal_activity_features(\nL247: def build_sequence_parts(\nL314: def final_user_features(\nL341: def prepare_data(\nL471: def cache_metadata(stage: str, config: Config) -> dict[str, object]:\nL481: def save_cache(\nL493: def load_cache(path: Path, stage: str, config: Config) -> SequenceData:\nL511: def load_or_prepare(\nL534: def build_item_correction(\nL578: def build_known_positive_filter(\nL609: def invalid_full_history_negatives(\nL630: def draw_full_history_filtered_negatives(\nL724: def draw_training_negatives(\nL763: def event_sequence(\nL774: def pool_explicit_states(\nL798: def user_queries(\nL813: def candidate_vectors(\nL828: def history_windows(\nL845: def corrected_negative_loss(\nL867: def retained_target_window_starts(\nL888: def chronological_target_partition(\nL914: def load_organic_like_outcomes(\nL955: def build_target_weights(\nL1035: def build_dense_block(\nL1111: def score_target_microbatches(\nL1198: def release_accelerator_cache(device: torch.device) -> None:\nL1203: def run_training_epoch(\nL1364: def evaluate_validation_bce(\nL1488: def snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\nL1495: def save_epoch_checkpoint(\nL1521: def train_model(\nL1782: def inference_queries(\nL1861: def rank_candidates(\nL1912: def write_ranking(frame: pd.DataFrame, output: Path) -> None:\nL1922: def main() -> int:\n---\nFile: two_tower_model.py\nL65: def log(message: str) -> None:\nL69: def build_item_features(catalog: pd.DataFrame) -> np.ndarray:\nL90: def _combine_listen_chunks(parts: list[ListenEvents]) -> ListenEvents:\nL106: def iter_listen_users(\nL157: def merge_listen_streams(\nL175: def load_explicit_events(\nL228: def empty_explicit_events() -> ExplicitEvents:\nL238: def pack_active_items(\nL251: def load_inference_state(\nL287: def __init__(self, item_features: np.ndarray, config: TowerConfig) -> None:\nL332: def _mean_context_channel(self, items: torch.Tensor) -> torch.Tensor:\nL339: def encode_items(self, items: torch.Tensor) -> torch.Tensor:\nL346: def invalid_negative_mask(\nL363: def draw_filtered_mixed_negatives(\n---"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:10.711Z",
"resultDisplay": {
"summary": "Found 57 matches",
"matches": [
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 82,
"line": " def read(cls, path: Path) -> \"CandidateSet\":"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 118,
"line": " def lengths(self) -> np.ndarray:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 122,
"line": " def target_count(self) -> int:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 136,
"line": " def selected_count(self) -> int:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 140,
"line": "def log(message: str) -> None:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 144,
"line": "def seed_everything(seed: int) -> None:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 150,
"line": "def model_config(config: Config) -> base.TowerConfig:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 174,
"line": "def append_state_snapshot("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 190,
"line": "def causal_activity_features("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 247,
"line": "def build_sequence_parts("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 314,
"line": "def final_user_features("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 341,
"line": "def prepare_data("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 471,
"line": "def cache_metadata(stage: str, config: Config) -> dict[str, object]:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 481,
"line": "def save_cache("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 493,
"line": "def load_cache(path: Path, stage: str, config: Config) -> SequenceData:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 511,
"line": "def load_or_prepare("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 534,
"line": "def build_item_correction("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 578,
"line": "def build_known_positive_filter("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 609,
"line": "def invalid_full_history_negatives("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 630,
"line": "def draw_full_history_filtered_negatives("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 724,
"line": "def draw_training_negatives("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 763,
"line": "def event_sequence("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 774,
"line": "def pool_explicit_states("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 798,
"line": "def user_queries("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 813,
"line": "def candidate_vectors("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 828,
"line": "def history_windows("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 845,
"line": "def corrected_negative_loss("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 867,
"line": "def retained_target_window_starts("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 888,
"line": "def chronological_target_partition("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 914,
"line": "def load_organic_like_outcomes("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 955,
"line": "def build_target_weights("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1035,
"line": "def build_dense_block("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1111,
"line": "def score_target_microbatches("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1198,
"line": "def release_accelerator_cache(device: torch.device) -> None:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1203,
"line": "def run_training_epoch("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1364,
"line": "def evaluate_validation_bce("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1488,
"line": "def snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1495,
"line": "def save_epoch_checkpoint("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1521,
"line": "def train_model("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1782,
"line": "def inference_queries("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1861,
"line": "def rank_candidates("
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1912,
"line": "def write_ranking(frame: pd.DataFrame, output: Path) -> None:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1922,
"line": "def main() -> int:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 65,
"line": "def log(message: str) -> None:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 69,
"line": "def build_item_features(catalog: pd.DataFrame) -> np.ndarray:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 90,
"line": "def _combine_listen_chunks(parts: list[ListenEvents]) -> ListenEvents:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 106,
"line": "def iter_listen_users("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 157,
"line": "def merge_listen_streams("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 175,
"line": "def load_explicit_events("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 228,
"line": "def empty_explicit_events() -> ExplicitEvents:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 238,
"line": "def pack_active_items("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 251,
"line": "def load_inference_state("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 287,
"line": " def __init__(self, item_features: np.ndarray, config: TowerConfig) -> None:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 332,
"line": " def _mean_context_channel(self, items: torch.Tensor) -> torch.Tensor:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 339,
"line": " def encode_items(self, items: torch.Tensor) -> torch.Tensor:"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 346,
"line": "def invalid_negative_mask("
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 363,
"line": "def draw_filtered_mixed_negatives("
}
]
},
"description": "'def ' within ../task/current_model",
"displayName": "SearchText",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:10.712Z",
"content": "Found 57 matches for pattern \"def \" in path \"/task/current_model\":\n---\nFile: train_current_model.py\nL82: def read(cls, path: Path) -> \"CandidateSet\":\nL118: def lengths(self) -> np.ndarray:\nL122: def target_count(self) -> int:\nL136: def selected_count(self) -> int:\nL140: def log(message: str) -> None:\nL144: def seed_everything(seed: int) -> None:\nL150: def model_config(config: Config) -> base.TowerConfig:\nL174: def append_state_snapshot(\nL190: def causal_activity_features(\nL247: def build_sequence_parts(\nL314: def final_user_features(\nL341: def prepare_data(\nL471: def cache_metadata(stage: str, config: Config) -> dict[str, object]:\nL481: def save_cache(\nL493: def load_cache(path: Path, stage: str, config: Config) -> SequenceData:\nL511: def load_or_prepare(\nL534: def build_item_correction(\nL578: def build_known_positive_filter(\nL609: def invalid_full_history_negatives(\nL630: def draw_full_history_filtered_negatives(\nL724: def draw_training_negatives(\nL763: def event_sequence(\nL774: def pool_explicit_states(\nL798: def user_queries(\nL813: def candidate_vectors(\nL828: def history_windows(\nL845: def corrected_negative_loss(\nL867: def retained_target_window_starts(\nL888: def chronological_target_partition(\nL914: def load_organic_like_outcomes(\nL955: def build_target_weights(\nL1035: def build_dense_block(\nL1111: def score_target_microbatches(\nL1198: def release_accelerator_cache(device: torch.device) -> None:\nL1203: def run_training_epoch(\nL1364: def evaluate_validation_bce(\nL1488: def snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\nL1495: def save_epoch_checkpoint(\nL1521: def train_model(\nL1782: def inference_queries(\nL1861: def rank_candidates(\nL1912: def write_ranking(frame: pd.DataFrame, output: Path) -> None:\nL1922: def main() -> int:\n---\nFile: two_tower_model.py\nL65: def log(message: str) -> None:\nL69: def build_item_features(catalog: pd.DataFrame) -> np.ndarray:\nL90: def _combine_listen_chunks(parts: list[ListenEvents]) -> ListenEvents:\nL106: def iter_listen_users(\nL157: def merge_listen_streams(\nL175: def load_explicit_events(\nL228: def empty_explicit_events() -> ExplicitEvents:\nL238: def pack_active_items(\nL251: def load_inference_state(\nL287: def __init__(self, item_features: np.ndarray, config: TowerConfig) -> None:\nL332: def _mean_context_channel(self, items: torch.Tensor) -> torch.Tensor:\nL339: def encode_items(self, items: torch.Tensor) -> torch.Tensor:\nL346: def invalid_negative_mask(\nL363: def draw_filtered_mixed_negatives(\n---",
"isError": false
},
"responseMessageId": "ec78dbdd-abf5-4bb8-8274-42dec926093b"
}
]
},
{
"id": 11,
"role": "agent",
"timestamp": "2026-09-29T05:37:13.446Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:37:13.446Z",
"text": "Testing Current Model\n\nI'm initiating the validation script for the current model now. My immediate focus is on observing its execution time to understand performance characteristics before proceeding further."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:13.446Z",
"callId": "read_file__call_33450",
"name": "read_file",
"input": {
"end_line": 170,
"start_line": 1,
"file_path": "/task/current_model/train_current_model.py"
},
"recorded": {
"id": "read_file__call_33450",
"name": "read_file",
"args": {
"end_line": 170,
"start_line": 1,
"file_path": "/task/current_model/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_33450",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1-170 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 171.\n\n--- FILE CONTENT (truncated) ---\n#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:13.450Z",
"resultDisplay": "Read lines 1-170 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:13.451Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1-170 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 171.\n\n--- FILE CONTENT (truncated) ---\n#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,",
"isError": false
},
"responseMessageId": "5f9fcffc-9095-4451-9cda-a511f50f4ebe"
}
]
},
{
"id": 12,
"role": "agent",
"timestamp": "2026-09-29T05:37:15.847Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:15.847Z",
"callId": "read_file__call_4836110",
"name": "read_file",
"input": {
"end_line": 760,
"start_line": 530,
"file_path": "/task/current_model/train_current_model.py"
},
"recorded": {
"id": "read_file__call_4836110",
"name": "read_file",
"args": {
"end_line": 760,
"start_line": 530,
"file_path": "/task/current_model/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_4836110",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 530-760 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 761.\n\n--- FILE CONTENT (truncated) ---\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:15.850Z",
"resultDisplay": "Read lines 530-760 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:15.851Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 530-760 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 761.\n\n--- FILE CONTENT (truncated) ---\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )",
"isError": false
},
"responseMessageId": "df5e3f8c-1e19-409e-a5d4-293e3b2e47f0"
}
]
},
{
"id": 13,
"role": "agent",
"timestamp": "2026-09-29T05:37:18.075Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:18.075Z",
"callId": "read_file__call_141422",
"name": "read_file",
"input": {
"end_line": 1000,
"start_line": 761,
"file_path": "/task/current_model/train_current_model.py"
},
"recorded": {
"id": "read_file__call_141422",
"name": "read_file",
"args": {
"end_line": 1000,
"start_line": 761,
"file_path": "/task/current_model/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_141422",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 761-1000 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1001.\n\n--- FILE CONTENT (truncated) ---\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:18.078Z",
"resultDisplay": "Read lines 761-1000 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:18.078Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 761-1000 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1001.\n\n--- FILE CONTENT (truncated) ---\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])",
"isError": false
},
"responseMessageId": "82c4427f-035a-43f3-8bce-7c21f9bc798d"
}
]
},
{
"id": 14,
"role": "agent",
"timestamp": "2026-09-29T05:37:20.105Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:20.105Z",
"callId": "read_file__call_134459",
"name": "read_file",
"input": {
"file_path": "/task/current_model/train_current_model.py",
"end_line": 1350,
"start_line": 1001
},
"recorded": {
"id": "read_file__call_134459",
"name": "read_file",
"args": {
"file_path": "/task/current_model/train_current_model.py",
"end_line": 1350,
"start_line": 1001
},
"result": [
{
"functionResponse": {
"id": "read_file__call_134459",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1001-1350 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1351.\n\n--- FILE CONTENT (truncated) ---\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:20.108Z",
"resultDisplay": "Read lines 1001-1350 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:20.108Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1001-1350 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1351.\n\n--- FILE CONTENT (truncated) ---\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),",
"isError": false
},
"responseMessageId": "67758e25-5e80-464d-bdeb-e887350f50e7"
}
]
},
{
"id": 15,
"role": "agent",
"timestamp": "2026-09-29T05:37:22.072Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:22.072Z",
"callId": "read_file__call_5688288",
"name": "read_file",
"input": {
"end_line": 1600,
"start_line": 1351,
"file_path": "/task/current_model/train_current_model.py"
},
"recorded": {
"id": "read_file__call_5688288",
"name": "read_file",
"args": {
"end_line": 1600,
"start_line": 1351,
"file_path": "/task/current_model/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_5688288",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1351-1600 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1601.\n\n--- FILE CONTENT (truncated) ---\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get("
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:22.075Z",
"resultDisplay": "Read lines 1351-1600 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:22.076Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1351-1600 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1601.\n\n--- FILE CONTENT (truncated) ---\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(",
"isError": false
},
"responseMessageId": "d3531e98-d507-46a8-9957-5beedea88e68"
}
]
},
{
"id": 16,
"role": "agent",
"timestamp": "2026-09-29T05:37:24.101Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:24.101Z",
"callId": "read_file__call_92458",
"name": "read_file",
"input": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 1601,
"end_line": 2000
},
"recorded": {
"id": "read_file__call_92458",
"name": "read_file",
"args": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 1601,
"end_line": 2000
},
"result": [
{
"functionResponse": {
"id": "read_file__call_92458",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1601-2000 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2001.\n\n--- FILE CONTENT (truncated) ---\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:24.104Z",
"resultDisplay": "Read lines 1601-2000 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:24.105Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1601-2000 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2001.\n\n--- FILE CONTENT (truncated) ---\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)",
"isError": false
},
"responseMessageId": "d01b1f05-d50d-477c-8d3f-f15878aa0584"
}
]
},
{
"id": 17,
"role": "agent",
"timestamp": "2026-09-29T05:37:28.032Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:28.032Z",
"callId": "read_file__call_218590",
"name": "read_file",
"input": {
"end_line": 2165,
"start_line": 2001,
"file_path": "/task/current_model/train_current_model.py"
},
"recorded": {
"id": "read_file__call_218590",
"name": "read_file",
"args": {
"end_line": 2165,
"start_line": 2001,
"file_path": "/task/current_model/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_218590",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2001-2165 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2166.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:28.035Z",
"resultDisplay": "Read lines 2001-2165 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:28.037Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2001-2165 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2166.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"isError": false
},
"responseMessageId": "b7e90c39-7c0e-465d-ad05-d9e4eae7ed0c"
}
]
},
{
"id": 18,
"role": "agent",
"timestamp": "2026-09-29T05:37:30.997Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:37:30.997Z",
"text": "Running Reproduction\n\nI'm executing the reproduction command now to see the immediate outcome. This should give us a baseline before any further refinements."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:30.997Z",
"callId": "run_shell_command__call_164961",
"name": "run_shell_command",
"input": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepare-only",
"description": "Test data preparation runtime for validation stage"
},
"recorded": {
"id": "run_shell_command__call_164961",
"name": "run_shell_command",
"args": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepare-only",
"description": "Test data preparation runtime for validation stage"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_164961",
"name": "run_shell_command",
"response": {
"output": "\nOutput: usage: train_current_model.py [-h] [--stage {validation,submission}] --output\n OUTPUT --public-dir PUBLIC_DIR\n [--prepared-cache PREPARED_CACHE]\n [--device {cpu,mps}] [--threads THREADS]\n [--bptt-steps BPTT_STEPS]\n [--user-batch-size USER_BATCH_SIZE]\n [--epochs EPOCHS]\n [--learning-rate LEARNING_RATE]\n [--loss-microbatch-size LOSS_MICROBATCH_SIZE]\n [--negative-filter-scope {full-training-history,last-100}]\n [--target-weighting {discovery-graded,organic-strong,uniform}]\n [--ordinary-target-weight ORDINARY_TARGET_WEIGHT]\n [--organic-strong-target-weight ORGANIC_STRONG_TARGET_WEIGHT]\n [--organic-like-target-weight ORGANIC_LIKE_TARGET_WEIGHT]\n [--discovery-horizon-days DISCOVERY_HORIZON_DAYS]\n [--validation-fraction VALIDATION_FRACTION]\n [--max-train-targets-per-user MAX_TRAIN_TARGETS_PER_USER]\n [--max-validation-targets-per-user MAX_VALIDATION_TARGETS_PER_USER]\n [--early-stopping-patience EARLY_STOPPING_PATIENCE]\n [--early-stopping-min-delta EARLY_STOPPING_MIN_DELTA]\n [--checkpoint-dir CHECKPOINT_DIR]\n [--resume-checkpoint RESUME_CHECKPOINT]\n [--seed SEED]\n [--ranking-batch-size RANKING_BATCH_SIZE]\n [--prepare-only]\ntrain_current_model.py: error: the following arguments are required: --output\nExit Code: 2\nProcess Group PGID: 1639\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:34.952Z",
"resultDisplay": "usage: train_current_model.py [-h] [--stage {validation,submission}] --output\n OUTPUT --public-dir PUBLIC_DIR\n [--prepared-cache PREPARED_CACHE]\n [--device {cpu,mps}] [--threads THREADS]\n [--bptt-steps BPTT_STEPS]\n [--user-batch-size USER_BATCH_SIZE]\n [--epochs EPOCHS]\n [--learning-rate LEARNING_RATE]\n [--loss-microbatch-size LOSS_MICROBATCH_SIZE]\n [--negative-filter-scope {full-training-history,last-100}]\n [--target-weighting {discovery-graded,organic-strong,uniform}]\n [--ordinary-target-weight ORDINARY_TARGET_WEIGHT]\n [--organic-strong-target-weight ORGANIC_STRONG_TARGET_WEIGHT]\n [--organic-like-target-weight ORGANIC_LIKE_TARGET_WEIGHT]\n [--discovery-horizon-days DISCOVERY_HORIZON_DAYS]\n [--validation-fraction VALIDATION_FRACTION]\n [--max-train-targets-per-user MAX_TRAIN_TARGETS_PER_USER]\n [--max-validation-targets-per-user MAX_VALIDATION_TARGETS_PER_USER]\n [--early-stopping-patience EARLY_STOPPING_PATIENCE]\n [--early-stopping-min-delta EARLY_STOPPING_MIN_DELTA]\n [--checkpoint-dir CHECKPOINT_DIR]\n [--resume-checkpoint RESUME_CHECKPOINT]\n [--seed SEED]\n [--ranking-batch-size RANKING_BATCH_SIZE]\n [--prepare-only]\ntrain_current_model.py: error: the following arguments are required: --output",
"description": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepare-only",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:37:34.953Z",
"content": "\nOutput: usage: train_current_model.py [-h] [--stage {validation,submission}] --output\n OUTPUT --public-dir PUBLIC_DIR\n [--prepared-cache PREPARED_CACHE]\n [--device {cpu,mps}] [--threads THREADS]\n [--bptt-steps BPTT_STEPS]\n [--user-batch-size USER_BATCH_SIZE]\n [--epochs EPOCHS]\n [--learning-rate LEARNING_RATE]\n [--loss-microbatch-size LOSS_MICROBATCH_SIZE]\n [--negative-filter-scope {full-training-history,last-100}]\n [--target-weighting {discovery-graded,organic-strong,uniform}]\n [--ordinary-target-weight ORDINARY_TARGET_WEIGHT]\n [--organic-strong-target-weight ORGANIC_STRONG_TARGET_WEIGHT]\n [--organic-like-target-weight ORGANIC_LIKE_TARGET_WEIGHT]\n [--discovery-horizon-days DISCOVERY_HORIZON_DAYS]\n [--validation-fraction VALIDATION_FRACTION]\n [--max-train-targets-per-user MAX_TRAIN_TARGETS_PER_USER]\n [--max-validation-targets-per-user MAX_VALIDATION_TARGETS_PER_USER]\n [--early-stopping-patience EARLY_STOPPING_PATIENCE]\n [--early-stopping-min-delta EARLY_STOPPING_MIN_DELTA]\n [--checkpoint-dir CHECKPOINT_DIR]\n [--resume-checkpoint RESUME_CHECKPOINT]\n [--seed SEED]\n [--ranking-batch-size RANKING_BATCH_SIZE]\n [--prepare-only]\ntrain_current_model.py: error: the following arguments are required: --output\nExit Code: 2\nProcess Group PGID: 1639\n",
"isError": false
},
"responseMessageId": "e6d69507-6436-4202-b564-bf2b8e00bc91"
}
]
},
{
"id": 19,
"role": "agent",
"timestamp": "2026-09-29T05:37:37.854Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:37.854Z",
"callId": "read_file__call_139712",
"name": "read_file",
"input": {
"end_line": 535,
"file_path": "/task/current_model/train_current_model.py",
"start_line": 470
},
"recorded": {
"id": "read_file__call_139712",
"name": "read_file",
"args": {
"end_line": 535,
"file_path": "/task/current_model/train_current_model.py",
"start_line": 470
},
"result": [
{
"functionResponse": {
"id": "read_file__call_139712",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 470-535 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 536.\n\n--- FILE CONTENT (truncated) ---\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:37:37.860Z",
"resultDisplay": "Read lines 470-535 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:37:37.861Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 470-535 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 536.\n\n--- FILE CONTENT (truncated) ---\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,",
"isError": false
},
"responseMessageId": "63cdb31b-da79-498d-b08f-a040ae18019b"
}
]
},
{
"id": 20,
"role": "agent",
"timestamp": "2026-09-29T05:37:43.070Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:37:43.070Z",
"text": "Exploring Cache Locations\n\nI'm currently considering where to best store the prepared cache. The constraint to write deliverables and intermediate artifacts only under `/app/solution/` is key here, though I also need to evaluate if `/tmp` is a viable option for temporary caching to optimize performance and resource usage."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:37:43.070Z",
"callId": "run_shell_command__call_5960183",
"name": "run_shell_command",
"input": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --output /app/solution/production_validation.parquet",
"description": "Run baseline production model validation training and ranking"
},
"recorded": {
"id": "run_shell_command__call_5960183",
"name": "run_shell_command",
"args": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --output /app/solution/production_validation.parquet",
"description": "Run baseline production model validation training and ranking"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5960183",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded explicit events: rows=720,270 users=8,220\nprepared users=1,000 tokens=2,090,746 states=35,727 elapsed=4.9s\nprepared users=2,000 tokens=4,301,266 states=71,242 elapsed=9.9s\nprepared users=3,000 tokens=6,486,146 states=109,471 elapsed=15.1s\nprepared users=4,000 tokens=8,793,043 states=148,210 elapsed=20.6s\nprepared users=5,000 tokens=10,992,205 states=182,596 elapsed=25.5s\nprepared users=6,000 tokens=13,061,727 states=217,148 elapsed=30.2s\nprepared users=7,000 tokens=15,334,418 states=256,914 elapsed=35.7s\nprepared users=8,000 tokens=17,462,672 states=296,703 elapsed=41.1s\nprepared users=9,000 tokens=19,568,405 states=331,551 elapsed=45.8s\ntarget users without qualifying catalog sequence=7\nprepared stage=validation sequence_users=9,135 tokens=20,056,329 next_item_targets=20,047,194 states=339,133\nsaved public-derived full-sequence cache: /app/solution/validation_cache.npz\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\ntarget weighting=organic-strong min=0.250 mean=0.575 max=1.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.547529 running_bce=0.541614 elapsed=198.4s\nepoch=1/1 train_loss=0.53984 validation_loss=0.49664 pair_accuracy=0.755 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.5 validation_seconds=15.4\nrestored best validation-BCE checkpoint: epoch=1 loss=0.496636\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/production_validation.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 361.702,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5398380482933169,\n \"positive_logit\": 0.7427799585458127,\n \"negative_logit\": -0.6222247023150492,\n \"pair_accuracy\": 0.7547733612041563,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 632551.0,\n \"batches\": 266.0,\n \"seconds\": 211.50029177400006,\n \"validation_loss\": 0.49663621852386697,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 78769.25,\n \"validation_seconds\": 15.381582812999909\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.603016972541809,\n \"query_norm_std\": 0.7697497010231018,\n \"item_norm_mean\": 1.7570278644561768,\n \"item_norm_std\": 0.8279485106468201\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\nProcess Group PGID: 1650\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:43:49.161Z",
"resultDisplay": "loaded explicit events: rows=720,270 users=8,220\nprepared users=1,000 tokens=2,090,746 states=35,727 elapsed=4.9s\nprepared users=2,000 tokens=4,301,266 states=71,242 elapsed=9.9s\nprepared users=3,000 tokens=6,486,146 states=109,471 elapsed=15.1s\nprepared users=4,000 tokens=8,793,043 states=148,210 elapsed=20.6s\nprepared users=5,000 tokens=10,992,205 states=182,596 elapsed=25.5s\nprepared users=6,000 tokens=13,061,727 states=217,148 elapsed=30.2s\nprepared users=7,000 tokens=15,334,418 states=256,914 elapsed=35.7s\nprepared users=8,000 tokens=17,462,672 states=296,703 elapsed=41.1s\nprepared users=9,000 tokens=19,568,405 states=331,551 elapsed=45.8s\ntarget users without qualifying catalog sequence=7\nprepared stage=validation sequence_users=9,135 tokens=20,056,329 next_item_targets=20,047,194 states=339,133\nsaved public-derived full-sequence cache: /app/solution/validation_cache.npz\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\ntarget weighting=organic-strong min=0.250 mean=0.575 max=1.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.547529 running_bce=0.541614 elapsed=198.4s\nepoch=1/1 train_loss=0.53984 validation_loss=0.49664 pair_accuracy=0.755 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.5 validation_seconds=15.4\nrestored best validation-BCE checkpoint: epoch=1 loss=0.496636\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/production_validation.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 361.702,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5398380482933169,\n \"positive_logit\": 0.7427799585458127,\n \"negative_logit\": -0.6222247023150492,\n \"pair_accuracy\": 0.7547733612041563,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 632551.0,\n \"batches\": 266.0,\n \"seconds\": 211.50029177400006,\n \"validation_loss\": 0.49663621852386697,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 78769.25,\n \"validation_seconds\": 15.381582812999909\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.603016972541809,\n \"query_norm_std\": 0.7697497010231018,\n \"item_norm_mean\": 1.7570278644561768,\n \"item_norm_std\": 0.8279485106468201\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}",
"description": "Run baseline production model validation training and ranking",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:43:49.163Z",
"content": "\nOutput: loaded explicit events: rows=720,270 users=8,220\nprepared users=1,000 tokens=2,090,746 states=35,727 elapsed=4.9s\nprepared users=2,000 tokens=4,301,266 states=71,242 elapsed=9.9s\nprepared users=3,000 tokens=6,486,146 states=109,471 elapsed=15.1s\nprepared users=4,000 tokens=8,793,043 states=148,210 elapsed=20.6s\nprepared users=5,000 tokens=10,992,205 states=182,596 elapsed=25.5s\nprepared users=6,000 tokens=13,061,727 states=217,148 elapsed=30.2s\nprepared users=7,000 tokens=15,334,418 states=256,914 elapsed=35.7s\nprepared users=8,000 tokens=17,462,672 states=296,703 elapsed=41.1s\nprepared users=9,000 tokens=19,568,405 states=331,551 elapsed=45.8s\ntarget users without qualifying catalog sequence=7\nprepared stage=validation sequence_users=9,135 tokens=20,056,329 next_item_targets=20,047,194 states=339,133\nsaved public-derived full-sequence cache: /app/solution/validation_cache.npz\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\ntarget weighting=organic-strong min=0.250 mean=0.575 max=1.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.547529 running_bce=0.541614 elapsed=198.4s\nepoch=1/1 train_loss=0.53984 validation_loss=0.49664 pair_accuracy=0.755 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.5 validation_seconds=15.4\nrestored best validation-BCE checkpoint: epoch=1 loss=0.496636\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/production_validation.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 361.702,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"organic-strong\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5398380482933169,\n \"positive_logit\": 0.7427799585458127,\n \"negative_logit\": -0.6222247023150492,\n \"pair_accuracy\": 0.7547733612041563,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 632551.0,\n \"batches\": 266.0,\n \"seconds\": 211.50029177400006,\n \"validation_loss\": 0.49663621852386697,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 78769.25,\n \"validation_seconds\": 15.381582812999909\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.603016972541809,\n \"query_norm_std\": 0.7697497010231018,\n \"item_norm_mean\": 1.7570278644561768,\n \"item_norm_std\": 0.8279485106468201\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\nProcess Group PGID: 1650\n",
"isError": false
},
"responseMessageId": "9ad2bfe5-beb8-49a0-bdc4-f402300fd843"
}
]
},
{
"id": 21,
"role": "agent",
"timestamp": "2026-09-29T05:43:54.305Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:43:54.305Z",
"callId": "run_shell_command__call_4025247",
"name": "run_shell_command",
"input": {
"command": "python /task/evaluate_public.py /app/solution/production_validation.parquet",
"description": "Score baseline validation ranking"
},
"recorded": {
"id": "run_shell_command__call_4025247",
"name": "run_shell_command",
"args": {
"command": "python /task/evaluate_public.py /app/solution/production_validation.parquet",
"description": "Score baseline validation ranking"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_4025247",
"name": "run_shell_command",
"response": {
"output": "\nOutput: {\n \"model\": \"/app/solution/production_validation.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.02128,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 1710\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:43:57.687Z",
"resultDisplay": "{\n \"model\": \"/app/solution/production_validation.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.02128,\n \"quality_users\": 4263\n }\n}",
"description": "python /task/evaluate_public.py /app/solution/production_validation.parquet",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:43:57.689Z",
"content": "\nOutput: {\n \"model\": \"/app/solution/production_validation.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.02128,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 1710\n",
"isError": false
},
"responseMessageId": "d1f0c3cb-aaa4-410f-973b-c5bee2a43a31"
}
]
},
{
"id": 22,
"role": "agent",
"timestamp": "2026-09-29T05:44:00.316Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:44:00.316Z",
"callId": "run_shell_command__call_5168104",
"name": "run_shell_command",
"input": {
"description": "Check contents and sizes in /app/solution",
"command": "ls -lh /app/solution/"
},
"recorded": {
"id": "run_shell_command__call_5168104",
"name": "run_shell_command",
"args": {
"description": "Check contents and sizes in /app/solution",
"command": "ls -lh /app/solution/"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5168104",
"name": "run_shell_command",
"response": {
"output": "\nOutput: total 512M\n-rw-r--r-- 1 agent agent 1.2M Sep 29 05:43 production_validation.parquet\n-rw-r--r-- 1 agent agent 511M Sep 29 05:38 validation_cache.npz\nProcess Group PGID: 1730\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:44:00.333Z",
"resultDisplay": "total 512M\n-rw-r--r-- 1 agent agent 1.2M Sep 29 05:43 production_validation.parquet\n-rw-r--r-- 1 agent agent 511M Sep 29 05:38 validation_cache.npz",
"description": "ls -lh /app/solution/",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:44:00.334Z",
"content": "\nOutput: total 512M\n-rw-r--r-- 1 agent agent 1.2M Sep 29 05:43 production_validation.parquet\n-rw-r--r-- 1 agent agent 511M Sep 29 05:38 validation_cache.npz\nProcess Group PGID: 1730\n",
"isError": false
},
"responseMessageId": "1e25222b-0fd8-4816-9372-5292e0a43fca"
}
]
},
{
"id": 23,
"role": "agent",
"timestamp": "2026-09-29T05:44:02.406Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:44:02.406Z",
"callId": "run_shell_command__call_131292",
"name": "run_shell_command",
"input": {
"command": "df -h /app",
"description": "Check disk space"
},
"recorded": {
"id": "run_shell_command__call_131292",
"name": "run_shell_command",
"args": {
"command": "df -h /app",
"description": "Check disk space"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_131292",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Filesystem Size Used Avail Use% Mounted on\noverlay 96G 15G 82G 15% /\nProcess Group PGID: 1733\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:44:02.423Z",
"resultDisplay": "Filesystem Size Used Avail Use% Mounted on\noverlay 96G 15G 82G 15% /",
"description": "df -h /app",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:44:02.424Z",
"content": "\nOutput: Filesystem Size Used Avail Use% Mounted on\noverlay 96G 15G 82G 15% /\nProcess Group PGID: 1733\n",
"isError": false
},
"responseMessageId": "ac880dd2-f81a-4522-8c62-f245407d0e1f"
}
]
},
{
"id": 24,
"role": "agent",
"timestamp": "2026-09-29T05:44:39.526Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:39.526Z",
"text": "Generating Baseline Submission\n\nI'm currently focused on creating a temporary, valid baseline submission file immediately. My priority is to ensure this file is saved, adhering to the instruction to retain the best valid submission throughout the process and survive the deadline. I'm also considering the possibility of refitting on the `submission` stage."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:39.526Z",
"text": "Investigating Negative Sampling\n\nMy thoughts are now zeroed in on the trainer's negative sampling strategy. I'm dissecting how it selects and utilizes negative examples within the training objective to identify potential limitations. My immediate goal is to diagnose these issues before exploring improvements, all while keeping the CPU budget and public backtest validation in mind."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:39.526Z",
"text": "Refining Negative Sampling\n\nI'm currently deep-diving into the specifics of negative example selection within the training objective. My focus is on understanding the existing mechanisms, their limitations, and potential code paths for improvement, always keeping the CPU budget and public backtest validation in sight."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:39.526Z",
"text": "Analyzing Loss Function\n\nI'm analyzing the specific loss function being employed, particularly the implications of using sample-weighted binary cross-entropy. My current focus is on understanding if alternative objectives like softmax, InfoNCE, or BPR are viable and could potentially yield better results within the existing framework."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:39.526Z",
"text": "Exploring Negative Sampling Logic\n\nI'm now delving into the specifics of `draw_full_history_filtered_negatives`, `corrected_negative_loss`, `score_target_microbatches`, and `build_item_correction`. My aim is to thoroughly understand the current negative sampling implementation and identify any associated limitations, ensuring all changes align with the CPU budget and public backtest validation."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:44:39.526Z",
"callId": "update_topic__call_5964347",
"name": "update_topic",
"input": {
"summary": "Baseline model reproduced with validation NDCG@10 of 0.02128. Sequence cache is saved. Now analyzing the negative sampling implementation, candidate generation, loss function, and filtering logic to diagnose bottlenecks and limitations.",
"strategic_intent": "Analyze the current negative sampling strategy and loss objective in detail to identify limitations.",
"title": "Diagnosing Negative Sampling and Training Objective"
},
"recorded": {
"id": "update_topic__call_5964347",
"name": "update_topic",
"args": {
"summary": "Baseline model reproduced with validation NDCG@10 of 0.02128. Sequence cache is saved. Now analyzing the negative sampling implementation, candidate generation, loss function, and filtering logic to diagnose bottlenecks and limitations.",
"strategic_intent": "Analyze the current negative sampling strategy and loss objective in detail to identify limitations.",
"title": "Diagnosing Negative Sampling and Training Objective"
},
"result": [
{
"functionResponse": {
"id": "update_topic__call_5964347",
"name": "update_topic",
"response": {
"output": "Current topic: \"Diagnosing Negative Sampling and Training Objective\"\nTopic summary: Baseline model reproduced with validation NDCG@10 of 0.02128. Sequence cache is saved. Now analyzing the negative sampling implementation, candidate generation, loss function, and filtering logic to diagnose bottlenecks and limitations.\n\nStrategic Intent: Analyze the current negative sampling strategy and loss objective in detail to identify limitations."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:44:39.538Z",
"resultDisplay": "## 📂 Topic: **Diagnosing Negative Sampling and Training Objective**\n\n**Summary:**\nBaseline model reproduced with validation NDCG@10 of 0.02128. Sequence cache is saved. Now analyzing the negative sampling implementation, candidate generation, loss function, and filtering logic to diagnose bottlenecks and limitations.\n\n> [!STRATEGY]\n> **Intent:** Analyze the current negative sampling strategy and loss objective in detail to identify limitations.",
"description": "Update topic to: \"Diagnosing Negative Sampling and Training Objective\"",
"displayName": "Update Topic Context",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:44:39.539Z",
"content": "Current topic: \"Diagnosing Negative Sampling and Training Objective\"\nTopic summary: Baseline model reproduced with validation NDCG@10 of 0.02128. Sequence cache is saved. Now analyzing the negative sampling implementation, candidate generation, loss function, and filtering logic to diagnose bottlenecks and limitations.\n\nStrategic Intent: Analyze the current negative sampling strategy and loss objective in detail to identify limitations.",
"isError": false
},
"responseMessageId": "ee8e0686-23d6-4bd9-ba03-c99ce1cecdcd"
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:44:39.526Z",
"callId": "read_file__call_5964353",
"name": "read_file",
"input": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 535,
"end_line": 725
},
"recorded": {
"id": "read_file__call_5964353",
"name": "read_file",
"args": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 535,
"end_line": 725
},
"result": [
{
"functionResponse": {
"id": "read_file__call_5964353",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 535-725 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 726.\n\n--- FILE CONTENT (truncated) ---\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:44:39.538Z",
"resultDisplay": "Read lines 535-725 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:44:39.539Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 535-725 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 726.\n\n--- FILE CONTENT (truncated) ---\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,",
"isError": false
},
"responseMessageId": "ee8e0686-23d6-4bd9-ba03-c99ce1cecdcd"
}
]
},
{
"id": 25,
"role": "agent",
"timestamp": "2026-09-29T05:44:53.406Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Analyzing Loss Function\n\nI'm currently scrutinizing the `corrected_negative_loss` definition, paying close attention to lines 845-865 to understand its precise calculation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Refining Loss Components\n\nI'm now focusing on how the `corrected_negative_loss` integrates with `draw_full_history_filtered_negatives`, specifically examining the calculation of `corrected_count` and its implications for the loss distribution."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Investigating Sampling Strategy\n\nI'm examining the negative sampling logic, particularly how `priorities` are masked and how `torch.topk` selects indices. It seems `unique_targets` represents all unique items in the batch, and I need to clarify the origin and scope of the `targets` variable used in this context."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Clarifying Logit Calculation\n\nI'm reviewing the calculation of `positive_logits` and `negative_logits`, particularly within the `score_target_microbatches` function. I need to confirm if the current loss formulation equates to a Binary Cross-Entropy (BCE) loss, given the use of `F.softplus` on `positive_logits` and the subsequent aggregation with `negative_loss`."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Questioning Loss Averaging\n\nI'm questioning the division by 2.0 in the loss calculation. It appears to be averaging positive and negative losses. I need to re-evaluate how this averaging impacts the effective weight of each negative example, particularly in the context of multiple negatives per positive."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Revising Negative Sampling\n\nI'm re-evaluating the negative sampling strategy. The current approach uniformly samples from `unique_targets`, not proportionally to frequency, which might be a limitation. I need to investigate this further."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:44:53.406Z",
"text": "Revising In-Batch Sampling\n\nI'm realizing the in-batch sampling from `unique_targets` is uniform, not proportional to frequency, despite subsequent `item_correction` implying otherwise. This discrepancy requires further investigation."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:44:53.406Z",
"callId": "grep_search__call_34954",
"name": "grep_search",
"input": {
"pattern": "dislike",
"dir_path": "/task"
},
"recorded": {
"id": "grep_search__call_34954",
"name": "grep_search",
"args": {
"pattern": "dislike",
"dir_path": "/task"
},
"result": [
{
"functionResponse": {
"id": "grep_search__call_34954",
"name": "grep_search",
"response": {
"output": "Found 40 matches for pattern \"dislike\" in path \"/task\":\n---\nFile: current_model/train_current_model.py\nL110: disliked_states: np.ndarray\nL114: inference_disliked_items: np.ndarray\nL176: active_dislikes: dict[int, int],\nL179: disliked_states: list[np.ndarray],\nL183: disliked_states.append(\nL184: base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\nL186: state_counts.append((len(active_likes), len(active_dislikes)))\nL252: disliked_states: list[np.ndarray],\nL279: active_dislikes: dict[int, int] = {}\nL293: else active_dislikes\nL304: active_dislikes,\nL307: disliked_states,\nL320: dislike_count: int,\nL337: result[5] = np.log1p(dislike_count) / 4.0\nL369: inference_likes, inference_dislikes, like_counts, dislike_counts = (\nL383: disliked_states = [\nL384: np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\nL405: disliked_states,\nL427: int(dislike_counts[inference_row]),\nL440: np.log1p(dislike_counts[missing]) / 4.0\nL455: disliked_states=np.stack(disliked_states),\nL459: inference_disliked_items=inference_dislikes,\nL784: disliked_items = torch.from_numpy(\nL785: prepared.disliked_states[unique_states].astype(np.int64)\nL788: disliked_vectors = model._mean_context_channel(disliked_items)\nL793: disliked_vectors[inverse_rows],\nL802: disliked_vectors: torch.Tensor,\nL807: [sequence_vectors, liked_vectors, disliked_vectors, user_features],\nL1147: liked_vectors, disliked_vectors, _ = pool_explicit_states(\nL1159: disliked_vectors,\nL1844: disliked_items = torch.from_numpy(\nL1845: prepared.inference_disliked_items[output_rows].astype(np.int64)\nL1851: model._mean_context_channel(disliked_items),\n---\nFile: current_model/two_tower_model.py\nL22: DISLIKE_ITEMS = 24\nL184: (\"dislikes\", 1, 1, 0),\nL185: (\"undislikes\", 1, 0, 1),\nL265: disliked = np.full((len(uids), DISLIKE_ITEMS), n_items, dtype=np.uint16)\nL267: dislike_counts = np.zeros(len(uids), dtype=np.int32)\nL270: (\"disliked\", DISLIKE_ITEMS, disliked, dislike_counts),\nL281: return liked, disliked, like_counts, dislike_counts\n---"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:44:53.425Z",
"resultDisplay": {
"summary": "Found 40 matches",
"matches": [
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 110,
"line": " disliked_states: np.ndarray"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 114,
"line": " inference_disliked_items: np.ndarray"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 176,
"line": " active_dislikes: dict[int, int],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 179,
"line": " disliked_states: list[np.ndarray],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 183,
"line": " disliked_states.append("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 184,
"line": " base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 186,
"line": " state_counts.append((len(active_likes), len(active_dislikes)))"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 252,
"line": " disliked_states: list[np.ndarray],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 279,
"line": " active_dislikes: dict[int, int] = {}"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 293,
"line": " else active_dislikes"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 304,
"line": " active_dislikes,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 307,
"line": " disliked_states,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 320,
"line": " dislike_count: int,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 337,
"line": " result[5] = np.log1p(dislike_count) / 4.0"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 369,
"line": " inference_likes, inference_dislikes, like_counts, dislike_counts = ("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 383,
"line": " disliked_states = ["
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 384,
"line": " np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 405,
"line": " disliked_states,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 427,
"line": " int(dislike_counts[inference_row]),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 440,
"line": " np.log1p(dislike_counts[missing]) / 4.0"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 455,
"line": " disliked_states=np.stack(disliked_states),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 459,
"line": " inference_disliked_items=inference_dislikes,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 784,
"line": " disliked_items = torch.from_numpy("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 785,
"line": " prepared.disliked_states[unique_states].astype(np.int64)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 788,
"line": " disliked_vectors = model._mean_context_channel(disliked_items)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 793,
"line": " disliked_vectors[inverse_rows],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 802,
"line": " disliked_vectors: torch.Tensor,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 807,
"line": " [sequence_vectors, liked_vectors, disliked_vectors, user_features],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1147,
"line": " liked_vectors, disliked_vectors, _ = pool_explicit_states("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1159,
"line": " disliked_vectors,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1844,
"line": " disliked_items = torch.from_numpy("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1845,
"line": " prepared.inference_disliked_items[output_rows].astype(np.int64)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1851,
"line": " model._mean_context_channel(disliked_items),"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 22,
"line": "DISLIKE_ITEMS = 24"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 184,
"line": " (\"dislikes\", 1, 1, 0),"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 185,
"line": " (\"undislikes\", 1, 0, 1),"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 265,
"line": " disliked = np.full((len(uids), DISLIKE_ITEMS), n_items, dtype=np.uint16)"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 267,
"line": " dislike_counts = np.zeros(len(uids), dtype=np.int32)"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 270,
"line": " (\"disliked\", DISLIKE_ITEMS, disliked, dislike_counts),"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 281,
"line": " return liked, disliked, like_counts, dislike_counts"
}
]
},
"description": "'dislike' within ../task",
"displayName": "SearchText",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:44:53.427Z",
"content": "Found 40 matches for pattern \"dislike\" in path \"/task\":\n---\nFile: current_model/train_current_model.py\nL110: disliked_states: np.ndarray\nL114: inference_disliked_items: np.ndarray\nL176: active_dislikes: dict[int, int],\nL179: disliked_states: list[np.ndarray],\nL183: disliked_states.append(\nL184: base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\nL186: state_counts.append((len(active_likes), len(active_dislikes)))\nL252: disliked_states: list[np.ndarray],\nL279: active_dislikes: dict[int, int] = {}\nL293: else active_dislikes\nL304: active_dislikes,\nL307: disliked_states,\nL320: dislike_count: int,\nL337: result[5] = np.log1p(dislike_count) / 4.0\nL369: inference_likes, inference_dislikes, like_counts, dislike_counts = (\nL383: disliked_states = [\nL384: np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\nL405: disliked_states,\nL427: int(dislike_counts[inference_row]),\nL440: np.log1p(dislike_counts[missing]) / 4.0\nL455: disliked_states=np.stack(disliked_states),\nL459: inference_disliked_items=inference_dislikes,\nL784: disliked_items = torch.from_numpy(\nL785: prepared.disliked_states[unique_states].astype(np.int64)\nL788: disliked_vectors = model._mean_context_channel(disliked_items)\nL793: disliked_vectors[inverse_rows],\nL802: disliked_vectors: torch.Tensor,\nL807: [sequence_vectors, liked_vectors, disliked_vectors, user_features],\nL1147: liked_vectors, disliked_vectors, _ = pool_explicit_states(\nL1159: disliked_vectors,\nL1844: disliked_items = torch.from_numpy(\nL1845: prepared.inference_disliked_items[output_rows].astype(np.int64)\nL1851: model._mean_context_channel(disliked_items),\n---\nFile: current_model/two_tower_model.py\nL22: DISLIKE_ITEMS = 24\nL184: (\"dislikes\", 1, 1, 0),\nL185: (\"undislikes\", 1, 0, 1),\nL265: disliked = np.full((len(uids), DISLIKE_ITEMS), n_items, dtype=np.uint16)\nL267: dislike_counts = np.zeros(len(uids), dtype=np.int32)\nL270: (\"disliked\", DISLIKE_ITEMS, disliked, dislike_counts),\nL281: return liked, disliked, like_counts, dislike_counts\n---",
"isError": false
},
"responseMessageId": "56f725bf-0632-4246-ac1e-f9cab63e3af3"
}
]
},
{
"id": 26,
"role": "agent",
"timestamp": "2026-09-29T05:45:05.006Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:45:05.006Z",
"text": "Analyzing Dislikes Data\n\nI've realized that dislikes are solely an input feature for the user tower, specifically as `disliked_vectors`, and are not utilized as negative training examples. My next step is to thoroughly examine the columns within `train_listens.parquet` to understand all available data."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:45:05.006Z",
"callId": "read_file__call_94351",
"name": "read_file",
"input": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 240,
"end_line": 340
},
"recorded": {
"id": "read_file__call_94351",
"name": "read_file",
"args": {
"file_path": "/task/current_model/train_current_model.py",
"start_line": 240,
"end_line": 340
},
"result": [
{
"functionResponse": {
"id": "read_file__call_94351",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 240-340 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 341.\n\n--- FILE CONTENT (truncated) ---\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:45:05.011Z",
"resultDisplay": "Read lines 240-340 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:45:05.013Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 240-340 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 341.\n\n--- FILE CONTENT (truncated) ---\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n",
"isError": false
},
"responseMessageId": "a2b4c643-18b1-4dfa-a702-bb3ae7b5ff7c"
}
]
},
{
"id": 27,
"role": "agent",
"timestamp": "2026-09-29T05:45:07.673Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:45:07.673Z",
"callId": "read_file__call_99742",
"name": "read_file",
"input": {
"file_path": "/task/current_model/train_current_model.py",
"end_line": 470,
"start_line": 341
},
"recorded": {
"id": "read_file__call_99742",
"name": "read_file",
"args": {
"file_path": "/task/current_model/train_current_model.py",
"end_line": 470,
"start_line": 341
},
"result": [
{
"functionResponse": {
"id": "read_file__call_99742",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 341-470 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 471.\n\n--- FILE CONTENT (truncated) ---\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:45:07.678Z",
"resultDisplay": "Read lines 341-470 of 2165 from ../task/current_model/train_current_model.py",
"description": "../.../train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:45:07.679Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 341-470 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 471.\n\n--- FILE CONTENT (truncated) ---\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n",
"isError": false
},
"responseMessageId": "36aaa856-1df3-47aa-aaba-0e428b98c627"
}
]
},
{
"id": 28,
"role": "agent",
"timestamp": "2026-09-29T05:46:15.252Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Exploring Negative Sampling\n\nI'm currently delving into the specifics of negative sampling, particularly examining the `draw_full_history_filtered_negatives` function. My focus is on understanding how training data and the sampling process interact."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Refining Negative Sampling Strategies\n\nI'm now focusing on the mechanics of sampling, specifically the creation of uniform and in-batch negatives. I'm analyzing how `torch.randint` and `torch.unique` contribute to this process within the `draw_full_history_filtered_negatives` function."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Implementing Correction Logic\n\nI'm now focused on integrating the `item_correction` into the generated `negatives`. My current thinking revolves around precisely applying these corrections to the in-batch negatives, especially when `corrected_count` is present, to ensure accuracy."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Validating Negative Data\n\nI'm now examining the `invalid_full_history_negatives` function and comparing its logic with `build_known_positive_filter`. My primary focus is on how known positives are identified and used to filter out invalid negatives during training."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Understanding Sequence Boundaries\n\nI'm now scrutinizing how sequence boundaries are defined. It appears the `training_counts` variable, derived from `chronological_target_partition`, dictates the length of sequences considered, impacting the items packed into `prepared.sequence_items` for processing."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Clarifying Sequence Construction\n\nI'm refining my understanding of how sequences are built. It seems `chronological_target_partition` dictates sequence lengths using `history_training_counts`, impacting `prepared.sequence_items`. I'm now questioning if `prepared.sequence_items` reflects all user interactions, especially those not meeting completion thresholds or explicit likes."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Investigating Positive Identification\n\nI'm now re-evaluating how positive interactions are defined. It seems explicit likes are considered positives, but the filtering logic in `invalid_full_history_negatives` only uses `liked_items`, potentially excluding disliked or unliked items from consideration as true negatives. I'm questioning how retrieval and evaluation criteria, particularly regarding organic behavior and candidate eligibility, align with this."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Validating Evaluation Splits\n\nI'm now realizing a crucial point regarding candidate exclusion in evaluation splits. It appears validation candidates exclude all training encounters, and test candidates exclude both training and validation encounters, which is fundamental to discovery evaluation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Analyzing Training Targets\n\nI am currently examining how training targets are defined within `train_current_model.py`, specifically focusing on the `build_target_weights` function. My current analysis is centered on how repeat items within sequences are handled and their impact on target weights."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Revising Target Weighting\n\nI'm revisiting target weighting, noting the baseline defaulted to \"organic-strong\" which doesn't downweight repeats or specifically boost grade-3 likes. I'm now questioning if \"discovery-graded\" is the intended weighting for the stated objective."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Reconsidering Training Weights\n\nI'm now questioning the default \"organic-strong\" weighting, as it doesn't seem to align with downweighting repeated items or boosting grade-3 likes. I'm evaluating if \"discovery-graded\" is a more suitable approach given the stated objectives."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Validating In-Batch Negatives\n\nI'm now examining the `corrected_negative_loss` function, specifically lines 845-865 in `train_current_model.py`. My focus is on how logits and correction factors are used to calculate the loss for both uniform and in-batch negatives."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Calculating Negative Loss\n\nI am now analyzing the calculation within the `corrected_negative_loss` function, specifically how uniform and in-batch negative logits are averaged. My current focus is on confirming the weighted average calculation and its division by the total negative weight to determine the final loss per negative sample."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:46:15.252Z",
"text": "Adjusting Loss Calculation\n\nI'm re-examining the loss calculation, specifically the averaging of negative losses. It appears the current implementation divides the sum of negative losses by the number of negatives (32), influencing the gradient updates for each negative sample. This deviates from a standard binary cross-entropy approach where each negative loss contributes independently."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:46:15.252Z",
"callId": "grep_search__call_7844345",
"name": "grep_search",
"input": {
"dir_path": "/task",
"pattern": "negative"
},
"recorded": {
"id": "grep_search__call_7844345",
"name": "grep_search",
"args": {
"dir_path": "/task",
"pattern": "negative"
},
"result": [
{
"functionResponse": {
"id": "grep_search__call_7844345",
"name": "grep_search",
"response": {
"output": "Found 100 matches for pattern \"negative\" in path \"/task\" (results limited to 100 matches for performance):\n---\nFile: current_model/train_current_model.py\nL14: and 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nL56: uniform_negatives: int = 24\nL57: inbatch_negatives: int = 8\nL61: negative_filter_scope: str = \"full-training-history\"\nL165: uniform_negatives=config.uniform_negatives,\nL166: inbatch_negatives=config.inbatch_negatives,\nL477: \"event_time_feature\": \"exp-negative-gap-over-60-days\",\nL603: f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\nL609: def invalid_full_history_negatives(\nL610: negatives: np.ndarray,\nL616: \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\nL617: byte_columns = negatives >> 3\nL618: bit_columns = negatives & 7\nL621: invalid |= negatives == targets[:, None]\nL622: invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\nL623: for column in range(1, negatives.shape[1]):\nL625: negatives[:, column, None] == negatives[:, :column]\nL630: def draw_full_history_filtered_negatives(\nL641: \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\nL647: (batch_size, config.uniform_negatives),\nL653: if config.inbatch_negatives:\nL656: config.inbatch_negatives, max(len(unique_targets) - 1, 0)\nL672: if corrected_count < config.inbatch_negatives:\nL675: (batch_size, config.inbatch_negatives - corrected_count),\nL681: negatives = torch.cat([uniform, inbatch], dim=1).numpy()\nL682: correction = np.ones_like(negatives, dtype=np.float32)\nL685: :, config.uniform_negatives : config.uniform_negatives + corrected_count\nL688: invalid = invalid_full_history_negatives(\nL689: negatives,\nL697: torch.from_numpy(negatives).to(device),\nL706: negatives[invalid] = replacements\nL709: invalid = invalid_full_history_negatives(\nL710: negatives,\nL717: raise RuntimeError(\"full-history negative resampling failed\")\nL719: torch.from_numpy(negatives).to(device),\nL724: def draw_training_negatives(\nL736: if config.negative_filter_scope == \"full-training-history\":\nL738: raise RuntimeError(\"full-history negative filter was not built\")\nL739: return draw_full_history_filtered_negatives(\nL750: return base.draw_filtered_mixed_negatives(\nL755: config.uniform_negatives,\nL756: config.inbatch_negatives,\nL816: negatives: torch.Tensor,\nL818: all_items = torch.cat([positives, negatives.reshape(-1)])\nL822: negative_vectors = encoded[inverse[len(positives) :]].reshape(\nL823: len(positives), negatives.shape[1], -1\nL825: return positive_vectors, negative_vectors\nL845: def corrected_negative_loss(\nL851: total = config.uniform_negatives + config.inbatch_negatives\nL853: if config.uniform_negatives:\nL854: result += config.uniform_negatives * raw[\nL855: :, : config.uniform_negatives\nL857: if config.inbatch_negatives:\nL858: selected = slice(config.uniform_negatives, total)\nL860: result += config.inbatch_negatives * (\nL880: raise RuntimeError(\"chronological target partition produced negative counts\")\nL1119: negatives: torch.Tensor,\nL1120: negative_weights: torch.Tensor,\nL1134: \"negative_sum\": 0.0,\nL1162: positive_vectors, negative_vectors = candidate_vectors(\nL1165: negatives[begin:end],\nL1168: negative_logits = torch.einsum(\nL1169: \"bd,bkd->bk\", query_vectors, negative_vectors\nL1172: negative_loss = corrected_negative_loss(\nL1173: negative_logits, negative_weights[begin:end], config\nL1179: selected_weights * (positive_loss + negative_loss) / 2.0\nL1190: statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\nL1192: (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\nL1227: negative_count = config.uniform_negatives + config.inbatch_negatives\nL1232: total_negative = 0.0\nL1293: negatives, negative_weights = draw_training_negatives(\nL1314: negatives,\nL1315: negative_weights,\nL1331: total_negative += statistics[\"negative_sum\"]\nL1353: \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\nL1355: / max(total_targets * negative_count, 1),\nL1449: negatives, negative_weights = draw_training_negatives(\nL1469: negatives,\nL1470: negative_weights,\nL1567: if config.negative_filter_scope == \"full-training-history\"\nL1601: \"negative_filter_scope\", \"last-100\"\nL1629: stored_filter_scope != config.negative_filter_scope\nL1660: f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\nL1944: \"--negative-filter-scope\",\nL1946: default=Config.negative_filter_scope,\nL2034: negative_filter_scope=args.negative_filter_scope,\nL2136: \"negative_sampling\": (\nL2139: \"false_negative_filter\": config.negative_filter_scope,\n---\nFile: current_model/two_tower_model.py\nL40: uniform_negatives: int = 24\nL41: inbatch_negatives: int = 8\nL346: def invalid_negative_mask(\nL347: negatives: torch.Tensor,\nL353: invalid = negatives.eq(targets[:, None])\nL354: invalid |= negatives[:, :, None].eq(context_items[:, None, :]).any(dim=2)\nL355: invalid |= negatives[:, :, None].eq(liked_items[:, None, :]).any(dim=2)\nL356: for column in range(1, negatives.shape[1]):\nL357: invalid[:, column] |= negatives[:, column, None].eq(\nL358: negatives[:, :column]\nL363: def draw_filtered_mixed_negatives(\nL374: \"\"\"Draw uniform and unique-target in-batch negatives.\"\"\"\n---"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:46:15.270Z",
"resultDisplay": {
"summary": "Found 100 matches (limited)",
"matches": [
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 14,
"line": "and 24 uniform plus eight propensity-corrected unique in-batch negatives. Every"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 56,
"line": " uniform_negatives: int = 24"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 57,
"line": " inbatch_negatives: int = 8"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 61,
"line": " negative_filter_scope: str = \"full-training-history\""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 165,
"line": " uniform_negatives=config.uniform_negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 166,
"line": " inbatch_negatives=config.inbatch_negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 477,
"line": " \"event_time_feature\": \"exp-negative-gap-over-60-days\","
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 603,
"line": " f\"full-history false-negative filter: users={len(prepared.user_ids):,} \""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 609,
"line": "def invalid_full_history_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 610,
"line": " negatives: np.ndarray,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 616,
"line": " \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 617,
"line": " byte_columns = negatives >> 3"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 618,
"line": " bit_columns = negatives & 7"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 621,
"line": " invalid |= negatives == targets[:, None]"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 622,
"line": " invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 623,
"line": " for column in range(1, negatives.shape[1]):"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 625,
"line": " negatives[:, column, None] == negatives[:, :column]"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 630,
"line": "def draw_full_history_filtered_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 641,
"line": " \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 647,
"line": " (batch_size, config.uniform_negatives),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 653,
"line": " if config.inbatch_negatives:"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 656,
"line": " config.inbatch_negatives, max(len(unique_targets) - 1, 0)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 672,
"line": " if corrected_count < config.inbatch_negatives:"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 675,
"line": " (batch_size, config.inbatch_negatives - corrected_count),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 681,
"line": " negatives = torch.cat([uniform, inbatch], dim=1).numpy()"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 682,
"line": " correction = np.ones_like(negatives, dtype=np.float32)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 685,
"line": " :, config.uniform_negatives : config.uniform_negatives + corrected_count"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 688,
"line": " invalid = invalid_full_history_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 689,
"line": " negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 697,
"line": " torch.from_numpy(negatives).to(device),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 706,
"line": " negatives[invalid] = replacements"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 709,
"line": " invalid = invalid_full_history_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 710,
"line": " negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 717,
"line": " raise RuntimeError(\"full-history negative resampling failed\")"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 719,
"line": " torch.from_numpy(negatives).to(device),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 724,
"line": "def draw_training_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 736,
"line": " if config.negative_filter_scope == \"full-training-history\":"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 738,
"line": " raise RuntimeError(\"full-history negative filter was not built\")"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 739,
"line": " return draw_full_history_filtered_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 750,
"line": " return base.draw_filtered_mixed_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 755,
"line": " config.uniform_negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 756,
"line": " config.inbatch_negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 816,
"line": " negatives: torch.Tensor,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 818,
"line": " all_items = torch.cat([positives, negatives.reshape(-1)])"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 822,
"line": " negative_vectors = encoded[inverse[len(positives) :]].reshape("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 823,
"line": " len(positives), negatives.shape[1], -1"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 825,
"line": " return positive_vectors, negative_vectors"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 845,
"line": "def corrected_negative_loss("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 851,
"line": " total = config.uniform_negatives + config.inbatch_negatives"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 853,
"line": " if config.uniform_negatives:"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 854,
"line": " result += config.uniform_negatives * raw["
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 855,
"line": " :, : config.uniform_negatives"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 857,
"line": " if config.inbatch_negatives:"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 858,
"line": " selected = slice(config.uniform_negatives, total)"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 860,
"line": " result += config.inbatch_negatives * ("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 880,
"line": " raise RuntimeError(\"chronological target partition produced negative counts\")"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1119,
"line": " negatives: torch.Tensor,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1120,
"line": " negative_weights: torch.Tensor,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1134,
"line": " \"negative_sum\": 0.0,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1162,
"line": " positive_vectors, negative_vectors = candidate_vectors("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1165,
"line": " negatives[begin:end],"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1168,
"line": " negative_logits = torch.einsum("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1169,
"line": " \"bd,bkd->bk\", query_vectors, negative_vectors"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1172,
"line": " negative_loss = corrected_negative_loss("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1173,
"line": " negative_logits, negative_weights[begin:end], config"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1179,
"line": " selected_weights * (positive_loss + negative_loss) / 2.0"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1190,
"line": " statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1192,
"line": " (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1227,
"line": " negative_count = config.uniform_negatives + config.inbatch_negatives"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1232,
"line": " total_negative = 0.0"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1293,
"line": " negatives, negative_weights = draw_training_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1314,
"line": " negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1315,
"line": " negative_weights,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1331,
"line": " total_negative += statistics[\"negative_sum\"]"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1353,
"line": " \"negative_logit\": total_negative / max(total_targets * negative_count, 1),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1355,
"line": " / max(total_targets * negative_count, 1),"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1449,
"line": " negatives, negative_weights = draw_training_negatives("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1469,
"line": " negatives,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1470,
"line": " negative_weights,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1567,
"line": " if config.negative_filter_scope == \"full-training-history\""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1601,
"line": " \"negative_filter_scope\", \"last-100\""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1629,
"line": " stored_filter_scope != config.negative_filter_scope"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1660,
"line": " f\"{stored_filter_scope}->{config.negative_filter_scope}, \""
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1944,
"line": " \"--negative-filter-scope\","
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1946,
"line": " default=Config.negative_filter_scope,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 2034,
"line": " negative_filter_scope=args.negative_filter_scope,"
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 2136,
"line": " \"negative_sampling\": ("
},
{
"filePath": "current_model/train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 2139,
"line": " \"false_negative_filter\": config.negative_filter_scope,"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 40,
"line": " uniform_negatives: int = 24"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 41,
"line": " inbatch_negatives: int = 8"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 346,
"line": "def invalid_negative_mask("
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 347,
"line": " negatives: torch.Tensor,"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 353,
"line": " invalid = negatives.eq(targets[:, None])"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 354,
"line": " invalid |= negatives[:, :, None].eq(context_items[:, None, :]).any(dim=2)"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 355,
"line": " invalid |= negatives[:, :, None].eq(liked_items[:, None, :]).any(dim=2)"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 356,
"line": " for column in range(1, negatives.shape[1]):"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 357,
"line": " invalid[:, column] |= negatives[:, column, None].eq("
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 358,
"line": " negatives[:, :column]"
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 363,
"line": "def draw_filtered_mixed_negatives("
},
{
"filePath": "current_model/two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 374,
"line": " \"\"\"Draw uniform and unique-target in-batch negatives.\"\"\""
}
]
},
"description": "'negative' within ../task",
"displayName": "SearchText",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:46:15.271Z",
"content": "Found 100 matches for pattern \"negative\" in path \"/task\" (results limited to 100 matches for performance):\n---\nFile: current_model/train_current_model.py\nL14: and 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nL56: uniform_negatives: int = 24\nL57: inbatch_negatives: int = 8\nL61: negative_filter_scope: str = \"full-training-history\"\nL165: uniform_negatives=config.uniform_negatives,\nL166: inbatch_negatives=config.inbatch_negatives,\nL477: \"event_time_feature\": \"exp-negative-gap-over-60-days\",\nL603: f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\nL609: def invalid_full_history_negatives(\nL610: negatives: np.ndarray,\nL616: \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\nL617: byte_columns = negatives >> 3\nL618: bit_columns = negatives & 7\nL621: invalid |= negatives == targets[:, None]\nL622: invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\nL623: for column in range(1, negatives.shape[1]):\nL625: negatives[:, column, None] == negatives[:, :column]\nL630: def draw_full_history_filtered_negatives(\nL641: \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\nL647: (batch_size, config.uniform_negatives),\nL653: if config.inbatch_negatives:\nL656: config.inbatch_negatives, max(len(unique_targets) - 1, 0)\nL672: if corrected_count < config.inbatch_negatives:\nL675: (batch_size, config.inbatch_negatives - corrected_count),\nL681: negatives = torch.cat([uniform, inbatch], dim=1).numpy()\nL682: correction = np.ones_like(negatives, dtype=np.float32)\nL685: :, config.uniform_negatives : config.uniform_negatives + corrected_count\nL688: invalid = invalid_full_history_negatives(\nL689: negatives,\nL697: torch.from_numpy(negatives).to(device),\nL706: negatives[invalid] = replacements\nL709: invalid = invalid_full_history_negatives(\nL710: negatives,\nL717: raise RuntimeError(\"full-history negative resampling failed\")\nL719: torch.from_numpy(negatives).to(device),\nL724: def draw_training_negatives(\nL736: if config.negative_filter_scope == \"full-training-history\":\nL738: raise RuntimeError(\"full-history negative filter was not built\")\nL739: return draw_full_history_filtered_negatives(\nL750: return base.draw_filtered_mixed_negatives(\nL755: config.uniform_negatives,\nL756: config.inbatch_negatives,\nL816: negatives: torch.Tensor,\nL818: all_items = torch.cat([positives, negatives.reshape(-1)])\nL822: negative_vectors = encoded[inverse[len(positives) :]].reshape(\nL823: len(positives), negatives.shape[1], -1\nL825: return positive_vectors, negative_vectors\nL845: def corrected_negative_loss(\nL851: total = config.uniform_negatives + config.inbatch_negatives\nL853: if config.uniform_negatives:\nL854: result += config.uniform_negatives * raw[\nL855: :, : config.uniform_negatives\nL857: if config.inbatch_negatives:\nL858: selected = slice(config.uniform_negatives, total)\nL860: result += config.inbatch_negatives * (\nL880: raise RuntimeError(\"chronological target partition produced negative counts\")\nL1119: negatives: torch.Tensor,\nL1120: negative_weights: torch.Tensor,\nL1134: \"negative_sum\": 0.0,\nL1162: positive_vectors, negative_vectors = candidate_vectors(\nL1165: negatives[begin:end],\nL1168: negative_logits = torch.einsum(\nL1169: \"bd,bkd->bk\", query_vectors, negative_vectors\nL1172: negative_loss = corrected_negative_loss(\nL1173: negative_logits, negative_weights[begin:end], config\nL1179: selected_weights * (positive_loss + negative_loss) / 2.0\nL1190: statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\nL1192: (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\nL1227: negative_count = config.uniform_negatives + config.inbatch_negatives\nL1232: total_negative = 0.0\nL1293: negatives, negative_weights = draw_training_negatives(\nL1314: negatives,\nL1315: negative_weights,\nL1331: total_negative += statistics[\"negative_sum\"]\nL1353: \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\nL1355: / max(total_targets * negative_count, 1),\nL1449: negatives, negative_weights = draw_training_negatives(\nL1469: negatives,\nL1470: negative_weights,\nL1567: if config.negative_filter_scope == \"full-training-history\"\nL1601: \"negative_filter_scope\", \"last-100\"\nL1629: stored_filter_scope != config.negative_filter_scope\nL1660: f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\nL1944: \"--negative-filter-scope\",\nL1946: default=Config.negative_filter_scope,\nL2034: negative_filter_scope=args.negative_filter_scope,\nL2136: \"negative_sampling\": (\nL2139: \"false_negative_filter\": config.negative_filter_scope,\n---\nFile: current_model/two_tower_model.py\nL40: uniform_negatives: int = 24\nL41: inbatch_negatives: int = 8\nL346: def invalid_negative_mask(\nL347: negatives: torch.Tensor,\nL353: invalid = negatives.eq(targets[:, None])\nL354: invalid |= negatives[:, :, None].eq(context_items[:, None, :]).any(dim=2)\nL355: invalid |= negatives[:, :, None].eq(liked_items[:, None, :]).any(dim=2)\nL356: for column in range(1, negatives.shape[1]):\nL357: invalid[:, column] |= negatives[:, column, None].eq(\nL358: negatives[:, :column]\nL363: def draw_filtered_mixed_negatives(\nL374: \"\"\"Draw uniform and unique-target in-batch negatives.\"\"\"\n---",
"isError": false
},
"responseMessageId": "0315ae78-786e-4918-87c5-892f6cd028d1"
}
]
},
{
"id": 29,
"role": "agent",
"timestamp": "2026-09-29T05:47:03.476Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Investigating Negative Sampling\n\nMy current focus is on understanding the mechanics of negative sampling and the training process itself, specifically scrutinizing the `invalid_full_history_negatives` function and its parameters."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Exploring Data Packing\n\nI'm currently examining how positive items are packed into bytes for efficiency. My focus is on understanding the `build_known_positive_filter` function and the `packed` array it generates, specifically how it represents user positive item sets."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Analyzing User IDs\n\nI am currently examining the `user_row` variable within the training loop, particularly its relationship to `prepared.user_ids` and how it's utilized by `invalid_full_history_negatives`. I need to clarify its scope and origin."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Clarifying User Row Indexing\n\nI've pinpointed that the `users` variable, used for batching, actually represents indices into `train_users`, which in turn maps to `prepared.user_ids`. This clarifies how `flat_user_rows` indexes into `known_positive_packed`."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Revising Packed Data Interpretation\n\nI'm re-evaluating my understanding of `known_positive_packed`. It seems to include targets beyond the immediate training history, which conflicts with my prior assumptions about its exclusive content. This suggests a need to carefully examine how validation targets are indexed and handled within this structure."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Refining Negative Selection\n\nI'm now examining how `inbatch` negatives are drawn, particularly the logic in `draw_full_history_filtered_negatives`. The key insight is that items seen in the training prefix are filtered out from the negatives, influencing the selection process for validation targets."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Refining Negative Sample Generation\n\nI'm now focusing on how in-batch negatives are finalized. Specifically, I'm analyzing the `torch.randint` calls used to fill up any remaining `inbatch` negatives after initial filtering and how the `correction` array is adjusted to account for these additional samples."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Adjusting Invalid Negatives\n\nI've discovered that rejected in-batch negatives are replaced with uniform draws and their correction is set to 1.0. This is significant because popular items, frequently present in user histories, are more likely to be invalidated, affecting the sampling distribution."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Questioning Loss Functions\n\nI am now questioning the core loss function being employed. Is it a standard Binary Cross-Entropy, or does it utilize a form of Softmax, such as Sampled Softmax, In-Batch Softmax, or InfoNCE, which would significantly alter the training paradigm?"
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Investigating Loss Formulation\n\nI'm now questioning the loss function's suitability for large catalogs. Binary Cross-Entropy appears to be used, but its effectiveness in massive retrieval scenarios is suspect, and a 75% pair accuracy against random negatives suggests issues."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Reassessing Model Performance\n\nI'm recalculating the model's effectiveness based on pair accuracy, realizing a 75% rate against random negatives implies the true positive is ranked very low, around 7500th out of 30,000. This explains the poor NDCG scores."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Evaluating Loss Logic\n\nI am re-examining the Binary Cross-Entropy loss calculation. It appears the current formulation is too lenient, allowing a significant probability for negatives to be considered positive. This is problematic for retrieval where the positive must rank highest."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Revising BCE Loss Interpretation\n\nI'm reassessing my interpretation of the BCE loss. The presence of `F.softplus` in `corrected_negative_loss` suggests it's not a standard BCE, but rather a form of margin-based loss where negatives are penalized based on their logits. This might explain the observed behavior."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Refining Loss Interpretation\n\nI am now understanding that `F.softplus` in `corrected_negative_loss` indicates a margin-based loss, not standard BCE. This explains the lenient penalties on negatives and clarifies why the true positive might not consistently rank highest, especially against random negatives."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Questioning Negative Sample Counts\n\nI'm now questioning the exact number and selection method of negative samples. It appears only 8 in-batch negatives are sampled per target, despite a much larger pool of distinct items available in the batch, and I need to understand why candidate vectors are computed individually for each target."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Analyzing Batch Negative Counts\n\nI'm realizing that my understanding of in-batch negative counts was flawed. While only 8 negatives are sampled per target initially, the `score_target_microbatches` function processes these in a single microbatch due to its size. This means all unique positive and negative items are encoded and processed together. The subsequent calculation of logits involves a matrix multiplication between query vectors and the projected negative vectors, which are structured as `(B, K, D)`. This unified processing explains how the model considers a broader set of negatives within a single step, despite the initial sampling count."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Analyzing Loss Formulation Logic\n\nI am now analyzing the `torch.einsum` operation, realizing it performs 32 dot products per query. I'm also scrutinizing the current loss function, particularly `F.softplus` for positive loss and the `corrected_negative_loss` with propensity weighting. My focus is on understanding its limitations compared to other objectives like Softmax/InfoNCE or pairwise losses."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Comparing Loss Functions\n\nI am now comparing the current loss formulation to alternatives like BPR or margin ranking. The existing loss, unlike BCE, directly enforces the positive item's rank over negatives, which seems more appropriate."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Revising Correction Logic\n\nI'm now re-examining the `build_item_correction` function and its use of `config.inbatch_correction`. This logic is applied to probabilities derived from item counts and total items, aiming to adjust for sampling bias, which aligns with techniques used in other large-scale recommendation models."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Investigating Config Parameters\n\nI am now investigating the origin of the `inbatch_correction_power`, `inbatch_correction_min`, and `inbatch_correction_max` parameters, specifically how they are incorporated into the `corrected_negative_loss` function and their implications on the loss calculation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Adjusting Weighting Logic\n\nI'm realizing my interpretation of the `correction` factor's impact was reversed. It actually down-weights popular in-batch negatives and up-weights rare ones within the `corrected_negative_loss`, which seems counter-intuitive for retrieval tasks where popular items are often more relevant."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:03.476Z",
"text": "Questioning Correction Application\n\nI am now questioning the application of the correction factor. My understanding was it adjusts for popularity bias, but in-batch negatives are sampled uniformly, not proportionally to popularity. This makes the correction's purpose unclear."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:47:03.476Z",
"callId": "run_shell_command__call_5914501",
"name": "run_shell_command",
"input": {
"description": "Analyze baseline prediction distribution and popularity",
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/production_validation.parquet')\nprint('Number of rows:', len(df))\nprint('Unique items predicted:', df.item_id.nunique())\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Average popularity rank of top-100 predictions:', df.pop_rank.mean())\nprint('Min pop rank:', df.pop_rank.min(), 'Max pop rank:', df.pop_rank.max())\ntop10 = df[df['rank'] <= 10]\nprint('Average popularity rank of top-10 predictions:', top10.pop_rank.mean())\nprint('Top 10 most frequently predicted items:')\nprint(df.item_id.value_counts().head(10))\n\""
},
"recorded": {
"id": "run_shell_command__call_5914501",
"name": "run_shell_command",
"args": {
"description": "Analyze baseline prediction distribution and popularity",
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/production_validation.parquet')\nprint('Number of rows:', len(df))\nprint('Unique items predicted:', df.item_id.nunique())\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Average popularity rank of top-100 predictions:', df.pop_rank.mean())\nprint('Min pop rank:', df.pop_rank.min(), 'Max pop rank:', df.pop_rank.max())\ntop10 = df[df['rank'] <= 10]\nprint('Average popularity rank of top-10 predictions:', top10.pop_rank.mean())\nprint('Top 10 most frequently predicted items:')\nprint(df.item_id.value_counts().head(10))\n\""
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5914501",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Number of rows: 845600\nUnique items predicted: 2575\nAverage popularity rank of top-100 predictions: 2991.8002459791865\nMin pop rank: 1 Max pop rank: 29992\nAverage popularity rank of top-10 predictions: 2597.0539025543994\nTop 10 most frequently predicted items:\nitem_id\n6896222 5089\n7565403 4970\n2055777 4647\n8722394 4627\n5010168 4572\n5134208 4397\n3968387 4160\n8823268 4157\n6414220 4155\n8350060 4132\nName: count, dtype: int64\nProcess Group PGID: 1758\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:47:05.116Z",
"resultDisplay": "Number of rows: 845600\nUnique items predicted: 2575\nAverage popularity rank of top-100 predictions: 2991.8002459791865\nMin pop rank: 1 Max pop rank: 29992\nAverage popularity rank of top-10 predictions: 2597.0539025543994\nTop 10 most frequently predicted items:\nitem_id\n6896222 5089\n7565403 4970\n2055777 4647\n8722394 4627\n5010168 4572\n5134208 4397\n3968387 4160\n8823268 4157\n6414220 4155\n8350060 4132\nName: count, dtype: int64",
"description": "Analyze baseline prediction distribution and popularity",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:47:05.118Z",
"content": "\nOutput: Number of rows: 845600\nUnique items predicted: 2575\nAverage popularity rank of top-100 predictions: 2991.8002459791865\nMin pop rank: 1 Max pop rank: 29992\nAverage popularity rank of top-10 predictions: 2597.0539025543994\nTop 10 most frequently predicted items:\nitem_id\n6896222 5089\n7565403 4970\n2055777 4647\n8722394 4627\n5010168 4572\n5134208 4397\n3968387 4160\n8823268 4157\n6414220 4155\n8350060 4132\nName: count, dtype: int64\nProcess Group PGID: 1758\n",
"isError": false
},
"responseMessageId": "11e03d84-ac7a-4c9b-b07b-a6a5a80685f4"
}
]
},
{
"id": 30,
"role": "agent",
"timestamp": "2026-09-29T05:47:16.229Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:16.229Z",
"text": "Discovering Model Predictability\n\nI'm noticing a significant concentration in my predictions. Out of thousands of items and users, a very small subset of items is being repeatedly suggested, with a single item dominating over 60% of predictions. This indicates a potential bias or over-reliance on a few popular items."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:47:16.229Z",
"callId": "run_shell_command__call_5966347",
"name": "run_shell_command",
"input": {
"description": "Analyze ground truth validation items and their popularity",
"command": "python -c \"\nimport pandas as pd\nfrom ranking_evaluation import CandidateSet\nfrom evaluate_public import validation_truth, DATA\ntargets_frame = pd.read_parquet(DATA / 'target_users.parquet')\ntargets = set(targets_frame.uid.astype(int))\neligibility = CandidateSet(DATA / 'validation_eligible_candidates.npz')\ngraded = validation_truth(eligibility, targets)\ncatalog = pd.read_parquet(DATA / 'candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\n\nall_items = []\nfor uid, items in graded.items():\n for item, grade in items.items():\n all_items.append((item, grade, cat_map.get(item)))\n\ndf_truth = pd.DataFrame(all_items, columns=['item', 'grade', 'pop_rank'])\nprint('Total true positive instances in validation:', len(df_truth))\nprint('Unique true positive items:', df_truth.item.nunique())\nprint('Mean pop rank of true positives:', df_truth.pop_rank.mean())\nprint('Median pop rank of true positives:', df_truth.pop_rank.median())\nprint('Top 10 most frequent true positive items:')\nprint(df_truth.item.value_counts().head(10))\n\""
},
"recorded": {
"id": "run_shell_command__call_5966347",
"name": "run_shell_command",
"args": {
"description": "Analyze ground truth validation items and their popularity",
"command": "python -c \"\nimport pandas as pd\nfrom ranking_evaluation import CandidateSet\nfrom evaluate_public import validation_truth, DATA\ntargets_frame = pd.read_parquet(DATA / 'target_users.parquet')\ntargets = set(targets_frame.uid.astype(int))\neligibility = CandidateSet(DATA / 'validation_eligible_candidates.npz')\ngraded = validation_truth(eligibility, targets)\ncatalog = pd.read_parquet(DATA / 'candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\n\nall_items = []\nfor uid, items in graded.items():\n for item, grade in items.items():\n all_items.append((item, grade, cat_map.get(item)))\n\ndf_truth = pd.DataFrame(all_items, columns=['item', 'grade', 'pop_rank'])\nprint('Total true positive instances in validation:', len(df_truth))\nprint('Unique true positive items:', df_truth.item.nunique())\nprint('Mean pop rank of true positives:', df_truth.pop_rank.mean())\nprint('Median pop rank of true positives:', df_truth.pop_rank.median())\nprint('Top 10 most frequent true positive items:')\nprint(df_truth.item.value_counts().head(10))\n\""
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5966347",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Traceback (most recent call last):\n File \"\", line 3, in \nModuleNotFoundError: No module named 'ranking_evaluation'\nExit Code: 1\nProcess Group PGID: 1778\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:47:17.730Z",
"resultDisplay": "Traceback (most recent call last):\n File \"\", line 3, in \nModuleNotFoundError: No module named 'ranking_evaluation'",
"description": "Analyze ground truth validation items and their popularity",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:47:17.732Z",
"content": "\nOutput: Traceback (most recent call last):\n File \"\", line 3, in \nModuleNotFoundError: No module named 'ranking_evaluation'\nExit Code: 1\nProcess Group PGID: 1778\n",
"isError": false
},
"responseMessageId": "af8e60b5-3182-4170-91ab-77a42d4b05d9"
}
]
},
{
"id": 31,
"role": "agent",
"timestamp": "2026-09-29T05:47:21.918Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T05:47:21.918Z",
"callId": "run_shell_command__call_37617",
"name": "run_shell_command",
"input": {
"command": "PYTHONPATH=/task python -c \"\nimport pandas as pd\nfrom ranking_evaluation import CandidateSet\nfrom evaluate_public import validation_truth, DATA\ntargets_frame = pd.read_parquet(DATA / 'target_users.parquet')\ntargets = set(targets_frame.uid.astype(int))\neligibility = CandidateSet(DATA / 'validation_eligible_candidates.npz')\ngraded = validation_truth(eligibility, targets)\ncatalog = pd.read_parquet(DATA / 'candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\n\nall_items = []\nfor uid, items in graded.items():\n for item, grade in items.items():\n all_items.append((item, grade, cat_map.get(item)))\n\ndf_truth = pd.DataFrame(all_items, columns=['item', 'grade', 'pop_rank'])\nprint('Total true positive instances in validation:', len(df_truth))\nprint('Unique true positive items:', df_truth.item.nunique())\nprint('Mean pop rank of true positives:', df_truth.pop_rank.mean())\nprint('Median pop rank of true positives:', df_truth.pop_rank.median())\nprint('Quantiles of pop rank: 25%:', df_truth.pop_rank.quantile(0.25), '75%:', df_truth.pop_rank.quantile(0.75))\nprint('Top 10 most frequent true positive items:')\nprint(df_truth.item.value_counts().head(10))\n\"",
"description": "Analyze ground truth validation items and their popularity"
},
"recorded": {
"id": "run_shell_command__call_37617",
"name": "run_shell_command",
"args": {
"command": "PYTHONPATH=/task python -c \"\nimport pandas as pd\nfrom ranking_evaluation import CandidateSet\nfrom evaluate_public import validation_truth, DATA\ntargets_frame = pd.read_parquet(DATA / 'target_users.parquet')\ntargets = set(targets_frame.uid.astype(int))\neligibility = CandidateSet(DATA / 'validation_eligible_candidates.npz')\ngraded = validation_truth(eligibility, targets)\ncatalog = pd.read_parquet(DATA / 'candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\n\nall_items = []\nfor uid, items in graded.items():\n for item, grade in items.items():\n all_items.append((item, grade, cat_map.get(item)))\n\ndf_truth = pd.DataFrame(all_items, columns=['item', 'grade', 'pop_rank'])\nprint('Total true positive instances in validation:', len(df_truth))\nprint('Unique true positive items:', df_truth.item.nunique())\nprint('Mean pop rank of true positives:', df_truth.pop_rank.mean())\nprint('Median pop rank of true positives:', df_truth.pop_rank.median())\nprint('Quantiles of pop rank: 25%:', df_truth.pop_rank.quantile(0.25), '75%:', df_truth.pop_rank.quantile(0.75))\nprint('Top 10 most frequent true positive items:')\nprint(df_truth.item.value_counts().head(10))\n\"",
"description": "Analyze ground truth validation items and their popularity"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_37617",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Total true positive instances in validation: 37769\nUnique true positive items: 14124\nMean pop rank of true positives: 8463.087743916969\nMedian pop rank of true positives: 5622.0\nQuantiles of pop rank: 25%: 1733.0 75%: 13374.0\nTop 10 most frequent true positive items:\nitem\n6399259 173\n6252104 109\n8250570 88\n2055777 83\n1265696 77\n3134183 60\n7579671 51\n1005397 46\n4948220 45\n6625048 43\nName: count, dtype: int64\nProcess Group PGID: 1789\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:47:24.030Z",
"resultDisplay": "Total true positive instances in validation: 37769\nUnique true positive items: 14124\nMean pop rank of true positives: 8463.087743916969\nMedian pop rank of true positives: 5622.0\nQuantiles of pop rank: 25%: 1733.0 75%: 13374.0\nTop 10 most frequent true positive items:\nitem\n6399259 173\n6252104 109\n8250570 88\n2055777 83\n1265696 77\n3134183 60\n7579671 51\n1005397 46\n4948220 45\n6625048 43\nName: count, dtype: int64",
"description": "Analyze ground truth validation items and their popularity",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:47:25.386Z",
"content": "\nOutput: Total true positive instances in validation: 37769\nUnique true positive items: 14124\nMean pop rank of true positives: 8463.087743916969\nMedian pop rank of true positives: 5622.0\nQuantiles of pop rank: 25%: 1733.0 75%: 13374.0\nTop 10 most frequent true positive items:\nitem\n6399259 173\n6252104 109\n8250570 88\n2055777 83\n1265696 77\n3134183 60\n7579671 51\n1005397 46\n4948220 45\n6625048 43\nName: count, dtype: int64\nProcess Group PGID: 1789\n",
"isError": false
},
"responseMessageId": "a0185738-96f4-4286-b84a-82439a381256"
}
]
},
{
"id": 32,
"role": "agent",
"timestamp": "2026-09-29T05:47:53.449Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Analyzing True Positives\n\nI'm seeing encouraging signs in the true positive discoveries. The mean popularity rank is 8,463, with a median of 5,622. The 75th percentile sits at 13,374, and I've identified 14,124 unique true positive items so far, significantly outpacing the baseline model's 2,5 prediction."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Investigating Baseline Bias\n\nMy focus has shifted to understanding the baseline's peculiar preference for highly popular items. It appears the `build_item_features` function might be contributing to this by heavily weighting popularity metrics, potentially limiting its scope."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Refining Feature Engineering\n\nI'm now scrutinizing how features are generated and scaled. It seems features like `log1p(positives)` and `popularity_rank` are heavily influenced by highly popular items, potentially skewing the model. I'm re-evaluating the `build_item_features` function.\n\n**Examining Training Dynamics**\n\nMy attention has turned to the training process itself. Specifically, I'm investigating the contrast between the overwhelmingly unpopular nature of uniformly sampled negatives and the popular items dominating positive targets. This disparity seems significant."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Adjusting Loss Correction\n\nI've identified a critical issue in how in-batch negatives are weighted and corrected. The current method heavily penalizes popular items and disproportionately boosts unpopular ones within the loss calculation, leading to skewed gradients. I'm exploring adjustments to this correction mechanism."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Correcting Loss Weighting\n\nI've pinpointed a critical flaw in how loss is calculated. It appears my current setup heavily penalizes unpopular in-batch negatives while barely touching popular ones, leading to a learned bias towards recommending all popular items, which explains test-time performance."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Revising Negative Sampling\n\nI'm now digging into how negative examples are selected and utilized by the training objective. The current strategy of using 24 uniform and 8 in-batch negatives feels insufficient, and I'm exploring whether increasing the count or improving the quality of these negatives is key."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Exploring Negative Sampling Strategies\n\nI'm now considering alternative approaches for selecting negative examples, moving beyond uniform sampling. I'm investigating popularity-biased sampling and the inclusion of hard negatives, such as disliked items from user histories, to improve training."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Evaluating Loss Functions\n\nI'm now exploring alternative loss functions to address the observed bias. I'm considering Sampled Softmax or InfoNCE with appropriate temperature scaling. My current focus is on incorporating logQ correction to mitigate sampling bias, aiming to improve gradient behavior during training."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Comparing Loss Functions\n\nI'm analyzing how Sampled Softmax contrasts with BCE. Sampled Softmax's direct competition and amplified gradients for any negative outscoring the positive seem more potent than BCE's weaker signal, especially when many negatives barely beat the positive within an average."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Testing Loss Functions\n\nI'm currently comparing the behavior of Sampled Softmax and BCE. Sampled Softmax's amplified gradients for harder negatives appear more impactful than BCE's subtler signal, especially given how many negatives barely outperform positives in my current setup."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Analyzing Inference Dot-Products\n\nI've realized my current training is not aligned with the raw dot-product inference. The model needs to be trained to output logits such that their dot-product directly reflects the desired scoring, considering the constraints on inference."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:47:53.449Z",
"text": "Revising Training Objective\n\nI'm re-evaluating the core training objective to ensure it aligns with inference. The goal is to train the model to output logits whose dot-product directly reflects the desired scoring, respecting the serving contract and ranking invariance due to monotonic transformations."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:47:53.449Z",
"callId": "grep_search__call_156531",
"name": "grep_search",
"input": {
"dir_path": "/task/current_model",
"pattern": "uniform_negatives"
},
"recorded": {
"id": "grep_search__call_156531",
"name": "grep_search",
"args": {
"dir_path": "/task/current_model",
"pattern": "uniform_negatives"
},
"result": [
{
"functionResponse": {
"id": "grep_search__call_156531",
"name": "grep_search",
"response": {
"output": "Found 12 matches for pattern \"uniform_negatives\" in path \"/task/current_model\":\n---\nFile: train_current_model.py\nL56: uniform_negatives: int = 24\nL165: uniform_negatives=config.uniform_negatives,\nL647: (batch_size, config.uniform_negatives),\nL685: :, config.uniform_negatives : config.uniform_negatives + corrected_count\nL755: config.uniform_negatives,\nL851: total = config.uniform_negatives + config.inbatch_negatives\nL853: if config.uniform_negatives:\nL854: result += config.uniform_negatives * raw[\nL855: :, : config.uniform_negatives\nL858: selected = slice(config.uniform_negatives, total)\nL1227: negative_count = config.uniform_negatives + config.inbatch_negatives\n---\nFile: two_tower_model.py\nL40: uniform_negatives: int = 24\n---"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:47:53.465Z",
"resultDisplay": {
"summary": "Found 12 matches",
"matches": [
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 56,
"line": " uniform_negatives: int = 24"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 165,
"line": " uniform_negatives=config.uniform_negatives,"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 647,
"line": " (batch_size, config.uniform_negatives),"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 685,
"line": " :, config.uniform_negatives : config.uniform_negatives + corrected_count"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 755,
"line": " config.uniform_negatives,"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 851,
"line": " total = config.uniform_negatives + config.inbatch_negatives"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 853,
"line": " if config.uniform_negatives:"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 854,
"line": " result += config.uniform_negatives * raw["
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 855,
"line": " :, : config.uniform_negatives"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 858,
"line": " selected = slice(config.uniform_negatives, total)"
},
{
"filePath": "train_current_model.py",
"absolutePath": "/task/current_model/train_current_model.py",
"lineNumber": 1227,
"line": " negative_count = config.uniform_negatives + config.inbatch_negatives"
},
{
"filePath": "two_tower_model.py",
"absolutePath": "/task/current_model/two_tower_model.py",
"lineNumber": 40,
"line": " uniform_negatives: int = 24"
}
]
},
"description": "'uniform_negatives' within ../task/current_model",
"displayName": "SearchText",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:47:53.467Z",
"content": "Found 12 matches for pattern \"uniform_negatives\" in path \"/task/current_model\":\n---\nFile: train_current_model.py\nL56: uniform_negatives: int = 24\nL165: uniform_negatives=config.uniform_negatives,\nL647: (batch_size, config.uniform_negatives),\nL685: :, config.uniform_negatives : config.uniform_negatives + corrected_count\nL755: config.uniform_negatives,\nL851: total = config.uniform_negatives + config.inbatch_negatives\nL853: if config.uniform_negatives:\nL854: result += config.uniform_negatives * raw[\nL855: :, : config.uniform_negatives\nL858: selected = slice(config.uniform_negatives, total)\nL1227: negative_count = config.uniform_negatives + config.inbatch_negatives\n---\nFile: two_tower_model.py\nL40: uniform_negatives: int = 24\n---",
"isError": false
},
"responseMessageId": "b2fb8412-1e4d-4496-b8bd-c4e30bff8771"
}
]
},
{
"id": 33,
"role": "agent",
"timestamp": "2026-09-29T05:48:04.407Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:04.407Z",
"text": "Discovering Hardcoded Values\n\nI've found that `uniform_negatives` and `inbatch_negatives` aren't exposed as command-line arguments in `train_current_model.py` as I initially assumed. Instead, they are fixed within the `Config` class, set to 24 and 8 respectively, with `inbatch_correction_power` at 0.5. This significantly changes my approach to parameter tuning."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:04.407Z",
"text": "Examining In-Batch Negatives\n\nI'm now focused on understanding the role and implementation of `inbatch_negatives`. The code indicates it dynamically selects negatives from the current batch based on unique targets, with a `corrected_count` determined by the `inbatch_negatives` configuration. The `inbatch_correction_min` and `inbatch_correction_max` parameters also appear relevant to this process."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:04.407Z",
"text": "Refining Negative Sampling\n\nI'm digging into the in-batch negative sampling logic. It appears to select negatives from unique targets within the batch, capped by `corrected_count`. I'm also observing how filler negatives are added if the dynamic selection falls short of the configured `inbatch_negatives` value."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:04.407Z",
"text": "Investigating Negative Rejection\n\nI'm examining the loop that handles invalid negatives. It appears to replace invalid items, identified by historical data, with random selections. Notably, rejected in-batch items are then treated as ordinary uniform draws, impacting the `correction` array."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:48:04.407Z",
"callId": "run_shell_command__call_232940",
"name": "run_shell_command",
"input": {
"description": "Check inbatch negative behavior and replacement rate",
"command": "python -c \"\nimport numpy as np\nimport torch\nfrom pathlib import Path\nimport sys\nsys.path.insert(0, '/task/current_model')\nfrom train_current_model import load_cache, Config, chronological_target_partition, build_known_positive_filter, build_item_correction, build_dense_block, draw_full_history_filtered_negatives\n\nconfig = Config()\nprepared = load_cache(Path('/app/solution/validation_cache.npz'), 'validation', config)\npartition = chronological_target_partition(prepared, config.validation_fraction, config.max_train_targets_per_user, config.max_validation_targets_per_user)\nfilter_packed = build_known_positive_filter(prepared, partition.history_training_counts)\nitem_correction = build_item_correction(prepared, config, partition.window_starts, partition.training_counts)\n\n# Let's inspect a typical batch\nusers = np.arange(64)\nblock = build_dense_block(prepared, np.ones(len(prepared.sequence_items)), users, partition.window_starts[users], partition.training_counts[users], np.zeros(64, dtype=int), 0, 100, config)\nflat_scored = block[5].reshape(-1)\npositive_items = torch.from_numpy(block[4].reshape(-1)[flat_scored].astype(np.int64))\nflat_user_rows = np.broadcast_to(users[:, None], block[5].shape).reshape(-1)[flat_scored]\nliked_items = torch.from_numpy(prepared.liked_states[block[3].reshape(-1)[flat_scored]].astype(np.int64))\n\ngenerator = torch.Generator().manual_seed(42)\nprint('Scored targets in batch:', len(positive_items))\nprint('Unique targets in batch:', len(torch.unique(positive_items)))\n\nnegatives, correction = draw_full_history_filtered_negatives(\n positive_items, flat_user_rows, liked_items, filter_packed, len(prepared.item_ids), config, item_correction, generator, torch.device('cpu')\n)\nprint('Negatives shape:', negatives.shape)\nprint('Correction shape:', correction.shape)\nprint('Correction for inbatch negatives (cols 24..31):')\ninbatch_corr = correction[:, 24:].numpy()\nprint('Fraction of inbatch corrections equal to 1.0 (meaning replaced by uniform or default):', (inbatch_corr == 1.0).mean())\nprint('Min inbatch corr:', inbatch_corr.min(), 'Max inbatch corr:', inbatch_corr.max())\n\""
},
"recorded": {
"id": "run_shell_command__call_232940",
"name": "run_shell_command",
"args": {
"description": "Check inbatch negative behavior and replacement rate",
"command": "python -c \"\nimport numpy as np\nimport torch\nfrom pathlib import Path\nimport sys\nsys.path.insert(0, '/task/current_model')\nfrom train_current_model import load_cache, Config, chronological_target_partition, build_known_positive_filter, build_item_correction, build_dense_block, draw_full_history_filtered_negatives\n\nconfig = Config()\nprepared = load_cache(Path('/app/solution/validation_cache.npz'), 'validation', config)\npartition = chronological_target_partition(prepared, config.validation_fraction, config.max_train_targets_per_user, config.max_validation_targets_per_user)\nfilter_packed = build_known_positive_filter(prepared, partition.history_training_counts)\nitem_correction = build_item_correction(prepared, config, partition.window_starts, partition.training_counts)\n\n# Let's inspect a typical batch\nusers = np.arange(64)\nblock = build_dense_block(prepared, np.ones(len(prepared.sequence_items)), users, partition.window_starts[users], partition.training_counts[users], np.zeros(64, dtype=int), 0, 100, config)\nflat_scored = block[5].reshape(-1)\npositive_items = torch.from_numpy(block[4].reshape(-1)[flat_scored].astype(np.int64))\nflat_user_rows = np.broadcast_to(users[:, None], block[5].shape).reshape(-1)[flat_scored]\nliked_items = torch.from_numpy(prepared.liked_states[block[3].reshape(-1)[flat_scored]].astype(np.int64))\n\ngenerator = torch.Generator().manual_seed(42)\nprint('Scored targets in batch:', len(positive_items))\nprint('Unique targets in batch:', len(torch.unique(positive_items)))\n\nnegatives, correction = draw_full_history_filtered_negatives(\n positive_items, flat_user_rows, liked_items, filter_packed, len(prepared.item_ids), config, item_correction, generator, torch.device('cpu')\n)\nprint('Negatives shape:', negatives.shape)\nprint('Correction shape:', correction.shape)\nprint('Correction for inbatch negatives (cols 24..31):')\ninbatch_corr = correction[:, 24:].numpy()\nprint('Fraction of inbatch corrections equal to 1.0 (meaning replaced by uniform or default):', (inbatch_corr == 1.0).mean())\nprint('Min inbatch corr:', inbatch_corr.min(), 'Max inbatch corr:', inbatch_corr.max())\n\""
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_232940",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nScored targets in batch: 5644\nUnique targets in batch: 3484\nNegatives shape: torch.Size([5644, 32])\nCorrection shape: torch.Size([5644, 32])\nCorrection for inbatch negatives (cols 24..31):\nFraction of inbatch corrections equal to 1.0 (meaning replaced by uniform or default): 0.06400602409638555\nMin inbatch corr: 0.25 Max inbatch corr: 4.0\nProcess Group PGID: 1817\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:48:09.701Z",
"resultDisplay": "loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nScored targets in batch: 5644\nUnique targets in batch: 3484\nNegatives shape: torch.Size([5644, 32])\nCorrection shape: torch.Size([5644, 32])\nCorrection for inbatch negatives (cols 24..31):\nFraction of inbatch corrections equal to 1.0 (meaning replaced by uniform or default): 0.06400602409638555\nMin inbatch corr: 0.25 Max inbatch corr: 4.0",
"description": "Check inbatch negative behavior and replacement rate",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:48:09.702Z",
"content": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nScored targets in batch: 5644\nUnique targets in batch: 3484\nNegatives shape: torch.Size([5644, 32])\nCorrection shape: torch.Size([5644, 32])\nCorrection for inbatch negatives (cols 24..31):\nFraction of inbatch corrections equal to 1.0 (meaning replaced by uniform or default): 0.06400602409638555\nMin inbatch corr: 0.25 Max inbatch corr: 4.0\nProcess Group PGID: 1817\n",
"isError": false
},
"responseMessageId": "cec9ac91-2628-4ba4-b618-5c24ae05bc56"
}
]
},
{
"id": 34,
"role": "agent",
"timestamp": "2026-09-29T05:48:18.765Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:18.765Z",
"text": "Investigating Loss Calculation\n\nI'm currently examining the loss calculations, specifically focusing on the 6.4% of replacements completed. My attention has turned to `corrected_negative_loss` and its relationship with BCE loss, while also scrutinizing the use of BCE within `train_current_model.py` and the operations in `score_target_microbatches`."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:18.765Z",
"text": "Analyzing Loss Components\n\nMy current focus is on dissecting the `positive_loss` derived from `F.softplus(-positive_logits)` and its interplay with the `corrected_negative_loss`. I'm also investigating the averaging and summation within `loss_sum`, especially how `selected_weights` influence the overall calculation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:18.765Z",
"text": "Investigating Gradient Discrepancy\n\nI've identified a significant gradient discrepancy. My analysis shows the gradient for positives is approximately 0.5, while for negatives, it's capped at 0.0156, a factor of 32 difference. This is impacting my understanding of the loss dynamics."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:48:18.765Z",
"callId": "run_shell_command__call_149143",
"name": "run_shell_command",
"input": {
"command": "python -c \"\nimport pandas as pd\nimport numpy as np\nimport torch\n\n# Let's inspect the baseline model item embeddings\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\nprint('Top 5 catalog items by popularity:')\nprint(catalog.head(5)[['item_id', 'positive_listens', 'organic_positive_listens', 'popularity_rank']])\nprint('Bottom 5 catalog items:')\nprint(catalog.tail(5)[['item_id', 'positive_listens', 'organic_positive_listens', 'popularity_rank']])\n\"",
"description": "Check top and bottom catalog items"
},
"recorded": {
"id": "run_shell_command__call_149143",
"name": "run_shell_command",
"args": {
"command": "python -c \"\nimport pandas as pd\nimport numpy as np\nimport torch\n\n# Let's inspect the baseline model item embeddings\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\nprint('Top 5 catalog items by popularity:')\nprint(catalog.head(5)[['item_id', 'positive_listens', 'organic_positive_listens', 'popularity_rank']])\nprint('Bottom 5 catalog items:')\nprint(catalog.tail(5)[['item_id', 'positive_listens', 'organic_positive_listens', 'popularity_rank']])\n\"",
"description": "Check top and bottom catalog items"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_149143",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Top 5 catalog items by popularity:\n item_id positive_listens organic_positive_listens popularity_rank\n0 5862961 26615 20620 1\n1 6901374 25536 17347 2\n2 5635052 24691 17194 3\n3 3542184 24075 17699 4\n4 9378983 24036 18195 5\nBottom 5 catalog items:\n item_id positive_listens organic_positive_listens popularity_rank\n29995 1275692 163 81 29996\n29996 1280011 163 76 29997\n29997 1309246 163 138 29998\n29998 1634958 163 46 29999\n29999 1670524 163 73 30000\nProcess Group PGID: 1831\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:48:22.687Z",
"resultDisplay": "Top 5 catalog items by popularity:\n item_id positive_listens organic_positive_listens popularity_rank\n0 5862961 26615 20620 1\n1 6901374 25536 17347 2\n2 5635052 24691 17194 3\n3 3542184 24075 17699 4\n4 9378983 24036 18195 5\nBottom 5 catalog items:\n item_id positive_listens organic_positive_listens popularity_rank\n29995 1275692 163 81 29996\n29996 1280011 163 76 29997\n29997 1309246 163 138 29998\n29998 1634958 163 46 29999\n29999 1670524 163 73 30000",
"description": "Check top and bottom catalog items",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:48:22.689Z",
"content": "\nOutput: Top 5 catalog items by popularity:\n item_id positive_listens organic_positive_listens popularity_rank\n0 5862961 26615 20620 1\n1 6901374 25536 17347 2\n2 5635052 24691 17194 3\n3 3542184 24075 17699 4\n4 9378983 24036 18195 5\nBottom 5 catalog items:\n item_id positive_listens organic_positive_listens popularity_rank\n29995 1275692 163 81 29996\n29996 1280011 163 76 29997\n29997 1309246 163 138 29998\n29998 1634958 163 46 29999\n29999 1670524 163 73 30000\nProcess Group PGID: 1831\n",
"isError": false
},
"responseMessageId": "f56ae3d3-b062-4833-9858-a37b64eebd6f"
}
]
},
{
"id": 35,
"role": "agent",
"timestamp": "2026-09-29T05:48:26.139Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:48:26.139Z",
"text": "Analyzing Baseline Predictions\n\nMy focus has shifted to dissecting the baseline run. I'm currently examining the top 10 most frequent predictions from `production_validation.parquet` and investigating their popularity ranks and positive listen counts."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:48:26.139Z",
"callId": "run_shell_command__call_4841192",
"name": "run_shell_command",
"input": {
"description": "Check popularity of top predicted items",
"command": "python -c \"\nimport pandas as pd\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ntop_pred_items = [6896222, 7565403, 2055777, 8722394, 5010168, 5134208, 3968387, 8823268, 6414220, 8350060]\nprint(catalog[catalog.item_id.isin(top_pred_items)][['item_id', 'popularity_rank', 'positive_listens', 'organic_positive_listens']])\n\""
},
"recorded": {
"id": "run_shell_command__call_4841192",
"name": "run_shell_command",
"args": {
"description": "Check popularity of top predicted items",
"command": "python -c \"\nimport pandas as pd\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ntop_pred_items = [6896222, 7565403, 2055777, 8722394, 5010168, 5134208, 3968387, 8823268, 6414220, 8350060]\nprint(catalog[catalog.item_id.isin(top_pred_items)][['item_id', 'popularity_rank', 'positive_listens', 'organic_positive_listens']])\n\""
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_4841192",
"name": "run_shell_command",
"response": {
"output": "\nOutput: item_id popularity_rank positive_listens organic_positive_listens\n75 8823268 76 8956 7255\n305 5134208 306 5028 3633\n317 3968387 318 4914 3402\n633 8722394 634 3464 1695\n817 6896222 818 3020 2017\n1169 2055777 1170 2465 1558\n1528 8350060 1529 2115 1153\n2061 7565403 2062 1763 1152\n2946 5010168 2947 1385 1228\n3206 6414220 3207 1305 612\nProcess Group PGID: 1848\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:48:27.695Z",
"resultDisplay": "item_id popularity_rank positive_listens organic_positive_listens\n75 8823268 76 8956 7255\n305 5134208 306 5028 3633\n317 3968387 318 4914 3402\n633 8722394 634 3464 1695\n817 6896222 818 3020 2017\n1169 2055777 1170 2465 1558\n1528 8350060 1529 2115 1153\n2061 7565403 2062 1763 1152\n2946 5010168 2947 1385 1228\n3206 6414220 3207 1305 612",
"description": "Check popularity of top predicted items",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:48:27.697Z",
"content": "\nOutput: item_id popularity_rank positive_listens organic_positive_listens\n75 8823268 76 8956 7255\n305 5134208 306 5028 3633\n317 3968387 318 4914 3402\n633 8722394 634 3464 1695\n817 6896222 818 3020 2017\n1169 2055777 1170 2465 1558\n1528 8350060 1529 2115 1153\n2061 7565403 2062 1763 1152\n2946 5010168 2947 1385 1228\n3206 6414220 3207 1305 612\nProcess Group PGID: 1848\n",
"isError": false
},
"responseMessageId": "3dbd4cc2-bd3a-4ea8-8fa8-18565c0bbb8d"
}
]
},
{
"id": 36,
"role": "agent",
"timestamp": "2026-09-29T05:49:11.085Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Investigating Negative Sampling\n\nMy focus has shifted to a deep dive into the negative sampling and loss function mechanics. I'm particularly scrutinizing how the training objective identifies and leverages these negative examples, aiming to pinpoint any inherent limitations."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Refining Negative Sampling\n\nI'm currently dissecting the training objective's handling of negative examples, specifically examining pointwise BCE against alternatives like InfoNCE or pairwise methods. My goal is to identify weaknesses in the current approach and enhance it within the CPU constraint, ensuring ranking performance is maintained while adhering to deployment parameters."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Exploring Loss Functions\n\nI'm delving into the nuances of Softmax-based loss functions like InfoNCE. I'm particularly interested in how they inherently handle hard negatives due to their exponential gradient weighting, contrasting this with the current approach. I'm also investigating the impact of the number of uniform versus in-batch negatives."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Analyzing In-Batch Negatives\n\nI'm scrutinizing the selection of in-batch negatives. Given a batch size of 64 and up to 100 timesteps, yielding around 3,000-5,000 targets, I'm questioning why only 8 in-batch items are being chosen by `draw_full_history_filtered_negatives`. I'm currently examining the code snippet provided to understand this limitation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Investigating In-Batch Negatives\n\nI'm questioning why only 8 in-batch negatives are being drawn despite a large pool of potential negatives available from the batch. I'm investigating the logic behind this fixed number and its implications for the sampling strategy, contrasting it with typical two-tower approaches."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Optimizing Item Encoding\n\nI've identified a significant bottleneck in item encoding. With a substantial number of unique items generated from negatives, the item MLP is processing an excessive amount, contributing to long epoch times. I’m now exploring strategies to optimize this encoding process and its impact on retrieval performance."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Validating Experimental Setup\n\nI'm confirming our testing strategy, noting the pre-cached validation set and the swift ~2-3 minute per experiment runtime. Baseline analysis shows a ~4-minute total for training and ranking, which seems quite reasonable for exploration. I am re-reading the problem statement to ensure alignment."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Analyzing Sampling Parameters\n\nI am now examining the specific parameters used in the `train_current_model.py` script, focusing on the number of uniform and in-batch negatives, along with the various correction and weighting factors. I'm trying to understand the rationale behind these choices, particularly the fixed number of in-batch negatives (8), and how they interact with the overall training objective."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Investigating Target Weighting\n\nI'm focusing on the `--target-weighting discovery-graded` option. I'm reviewing the implementation details within `train_current_model.py` to understand how \"discovery-graded\" weighting is applied and how it integrates with the `load_organic_like_outcomes` function and horizon calculations."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Clarifying Target Splits\n\nI'm examining the logic for splitting training and validation targets based on user history and timestamps. I'm specifically analyzing how repeated items are handled and their assigned weights, ensuring the distinction between ordinary and discovery-graded targets is maintained correctly."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Clarifying Target Weights\n\nI'm now scrutinizing the `discovery-graded` target weighting. Specifically, I'm analyzing why it wasn't the default and how the weights of 3.0, 1.0, and 0.25 are applied based on different user engagement metrics. I'm examining the logic for determining these grades."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Evaluating Target Weighting\n\nI am now investigating the impact of `--target-weighting discovery-graded` versus the default `organic-strong`, focusing on how different user engagement metrics influence weight assignments. I'm clarifying the logic behind the 3.0, 1.0, and 0.25 weight grades."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Analyzing Negative Sampling Logic\n\nI am currently reviewing the `draw_training_negatives` function and its interaction with `draw_full_history_filtered_negatives`. My focus is on understanding how specific negative examples are selected and filtered based on the `negative_filter_scope` configuration parameter."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Filtering Negatives Further\n\nI'm now examining `invalid_negative_mask` to understand its filtering logic for negatives. It appears to be removing items already present in targets, context items, liked items, and even duplicates within the negatives themselves. My current focus is on how this interacts with the `negative_filter_scope` setting."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Examining Negative Selection\n\nI'm now looking at how `uniform` and `inbatch` negatives are selected within `draw_full_history_filtered_negatives`. My current task is to understand the logic that determines which specific negative examples are drawn, given the available pool and configuration parameters."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Understanding In-Batch Negative Draw\n\nI'm investigating the `draw_full_history_filtered_negatives` function and observed that `inbatch` is initialized as an empty tensor, only populated if `config.inbatch_negatives` is true. This suggests the number of in-batch negatives isn't dynamically adjusted to the available pool but rather by a configuration parameter."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Filtering In-Batch Negatives\n\nI'm scrutinizing the priority masking within `draw_full_history_filtered_negatives`. It seems designed to prevent selecting targets of the *current* row as in-batch negatives, but I need to confirm if it adequately handles cases where another user's target in the batch is already in the current user's history."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Revising In-Batch Negative Sampling\n\nI've uncovered a critical flaw in the in-batch negative sampling implementation. It's not leveraging the natural popularity bias of batch targets as expected, but rather sampling uniformly. This fundamentally undermines the intended benefit of in-batch negatives for recommendation systems."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Correcting In-Batch Sampling\n\nI've identified a critical flaw: uniform sampling from unique targets negates the inherent popularity bias needed for effective in-batch negatives. The current `item_correction` logic, intended to debias, doesn't account for this initial uniform sampling error, leading to an incorrect probability distribution."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Adjusting In-Batch Corrections\n\nI'm recalibrating the in-batch negative correction factors. My current analysis reveals that when popular items have low raw probabilities, they receive a disproportionately high correction factor (4.0), while rare items get a low one (0.25). This seems counterintuitive and requires adjustment to better align with expected behavior."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Correcting Weighting Logic\n\nI've discovered a significant issue where uniform sampling of negatives, particularly popular items, is being severely downweighted. This is counteracted by upweighting rare items, leading the model to favor popular tracks and hindering genuine discovery. I am now focused on fixing this problematic weighting mechanism."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Fixing Weighting Logic\n\nI'm correcting a significant issue where popular negative items were heavily downweighted by uniform sampling, while rare items were upweighted. This flawed weighting mechanism hindered discovery. I am now implementing changes to ensure a more balanced and effective training process."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:11.085Z",
"text": "Revising Loss Function\n\nI'm now shifting my focus from negative sampling mechanics to the core training objective. I'm exploring how various loss functions like InfoNCE, sampled softmax, and BPR should leverage negative examples, considering factors like popularity bias, hard negatives, and the use of temperature."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:49:11.085Z",
"callId": "run_shell_command__call_145690",
"name": "run_shell_command",
"input": {
"command": "cp /task/current_model/train_current_model.py /app/solution/train_current_model.py && cp /task/current_model/two_tower_model.py /app/solution/two_tower_model.py",
"description": "Copy model code to /app/solution"
},
"recorded": {
"id": "run_shell_command__call_145690",
"name": "run_shell_command",
"args": {
"command": "cp /task/current_model/train_current_model.py /app/solution/train_current_model.py && cp /task/current_model/two_tower_model.py /app/solution/two_tower_model.py",
"description": "Copy model code to /app/solution"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_145690",
"name": "run_shell_command",
"response": {
"output": "\nOutput: (empty)\nProcess Group PGID: 1871\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:49:11.107Z",
"resultDisplay": "",
"description": "Copy model code to /app/solution",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:49:11.109Z",
"content": "\nOutput: (empty)\nProcess Group PGID: 1871\n",
"isError": false
},
"responseMessageId": "a95fc306-ae41-4cd8-bd66-897490c9fa34"
}
]
},
{
"id": 37,
"role": "agent",
"timestamp": "2026-09-29T05:49:36.073Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Testing Training Objective\n\nI'm currently exploring modifications to the training objective and negative sampling strategies within `train_current_model.py`. The goal is to assess their impact via testing."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Evaluating Training Loss\n\nMy recent thoughts have focused on the efficiency of running quick experiments. I've noted that a single epoch with current settings is around four minutes, making rapid iteration feasible. I'm now considering specific hypotheses for the `corrected_negative_loss` function, particularly regarding the downweighting of popular negatives and exploring InfoNCE/Sampled Softmax as potential alternatives to BCE."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Refining Negative Sampling\n\nI'm currently exploring a correction to sampled softmax, specifically the log-Q correction from Yi et al. (2019). My focus is on how this correction interacts with popular negatives, especially when using popularity as the sampling probability. I'm investigating its implications for the positive term as well."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Analyzing Logit Bias\n\nI've realized that by subtracting its training logit, the model doesn't need an artificially high dot product for popular items during training. This means the raw dot product at inference accurately reflects true affinity, free from popularity bias. Without this correction, BCE was actually learning high dot products for popular items.\n\n**Exploring Negative Sampling Scales**\n\nI'm now considering variations on InfoNCE and Softmax, including those with in-batch negatives and log-Q corrections. I'm also investigating the impact of increasing the number of negatives, looking at how the current encoding time scales with larger negative sets and if using all unique in-batch targets as negatives is feasible."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Optimizing Unique Target Encoding\n\nI've discovered a significant optimization: encoding only ~3,500 unique targets per batch, rather than the previous ~15,000. This is because in-batch negatives mean all unique targets are already represented, drastically reducing encoding time by a factor of four. This approach also aligns with strategies for balancing selection bias and catalog coverage."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Investigating Batch Size\n\nI'm questioning the current ratio of uniform to in-batch negatives, wondering if increasing in-batch negatives or using popularity-biased samples would be more effective. I'm considering testing InfoNCE directly on the existing sampling setup to isolate the loss function's impact."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Adjusting Temperature Scale\n\nI'm now considering the optimal temperature scaling for InfoNCE. The current dot product range suggests values around 0.05 to 0.2 could significantly impact logits. I'm exploring a fixed $\\tau=0.1$ and the possibility of a learnable temperature parameter."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:49:36.073Z",
"text": "Investigating Log-Q Correction\n\nI'm now diving into the specifics of the log-Q correction as presented in Yi et al. (2019) for sampled softmax, considering its potential application within an InfoNCE framework. My current focus is on how incorporating $-\\log p_i$ directly into the logits, particularly with temperature scaling, might influence performance and mitigate popularity bias."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:49:36.073Z",
"callId": "update_topic__call_5150365",
"name": "update_topic",
"input": {
"summary": "Diagnosed the core issue: the current model uses a pointwise BCE loss where negative gradients are diluted (divided by 64), popular negatives are severely downweighted (loss weight 0.25), and there is no direct ranking competition. This causes the model to predict only ~2,500 popular items for all users. We will now test targeted improvements starting with discovery-graded weighting and InfoNCE/ranking loss objectives.",
"title": "Testing Loss Objectives and Negative Sampling",
"strategic_intent": "Run quick experiments with target weighting and loss functions on the validation backtest."
},
"recorded": {
"id": "update_topic__call_5150365",
"name": "update_topic",
"args": {
"summary": "Diagnosed the core issue: the current model uses a pointwise BCE loss where negative gradients are diluted (divided by 64), popular negatives are severely downweighted (loss weight 0.25), and there is no direct ranking competition. This causes the model to predict only ~2,500 popular items for all users. We will now test targeted improvements starting with discovery-graded weighting and InfoNCE/ranking loss objectives.",
"title": "Testing Loss Objectives and Negative Sampling",
"strategic_intent": "Run quick experiments with target weighting and loss functions on the validation backtest."
},
"result": [
{
"functionResponse": {
"id": "update_topic__call_5150365",
"name": "update_topic",
"response": {
"output": "Current topic: \"Testing Loss Objectives and Negative Sampling\"\nTopic summary: Diagnosed the core issue: the current model uses a pointwise BCE loss where negative gradients are diluted (divided by 64), popular negatives are severely downweighted (loss weight 0.25), and there is no direct ranking competition. This causes the model to predict only ~2,500 popular items for all users. We will now test targeted improvements starting with discovery-graded weighting and InfoNCE/ranking loss objectives.\n\nStrategic Intent: Run quick experiments with target weighting and loss functions on the validation backtest."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:55:00.048Z",
"resultDisplay": "## 📂 Topic: **Testing Loss Objectives and Negative Sampling**\n\n**Summary:**\nDiagnosed the core issue: the current model uses a pointwise BCE loss where negative gradients are diluted (divided by 64), popular negatives are severely downweighted (loss weight 0.25), and there is no direct ranking competition. This causes the model to predict only ~2,500 popular items for all users. We will now test targeted improvements starting with discovery-graded weighting and InfoNCE/ranking loss objectives.\n\n> [!STRATEGY]\n> **Intent:** Run quick experiments with target weighting and loss functions on the validation backtest.",
"description": "Update topic to: \"Testing Loss Objectives and Negative Sampling\"",
"displayName": "Update Topic Context",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T05:55:00.050Z",
"content": "Current topic: \"Testing Loss Objectives and Negative Sampling\"\nTopic summary: Diagnosed the core issue: the current model uses a pointwise BCE loss where negative gradients are diluted (divided by 64), popular negatives are severely downweighted (loss weight 0.25), and there is no direct ranking competition. This causes the model to predict only ~2,500 popular items for all users. We will now test targeted improvements starting with discovery-graded weighting and InfoNCE/ranking loss objectives.\n\nStrategic Intent: Run quick experiments with target weighting and loss functions on the validation backtest.",
"isError": false
},
"responseMessageId": "80ff37a2-7aa8-4d0f-8c79-f071c16e6c1f"
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:49:36.073Z",
"callId": "run_shell_command__call_5150373",
"name": "run_shell_command",
"input": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --output /app/solution/exp1_discovery_graded.parquet && \\\npython /task/evaluate_public.py /app/solution/exp1_discovery_graded.parquet",
"description": "Test baseline with discovery-graded target weighting"
},
"recorded": {
"id": "run_shell_command__call_5150373",
"name": "run_shell_command",
"args": {
"command": "python /task/current_model/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --output /app/solution/exp1_discovery_graded.parquet && \\\npython /task/evaluate_public.py /app/solution/exp1_discovery_graded.parquet",
"description": "Test baseline with discovery-graded target weighting"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5150373",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.551810 running_bce=0.544138 elapsed=196.1s\nepoch=1/1 train_loss=0.54212 validation_loss=0.50483 pair_accuracy=0.760 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.2 validation_seconds=15.5\nrestored best validation-BCE checkpoint: epoch=1 loss=0.504831\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.261,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.542115418840845,\n \"positive_logit\": 0.7774311445323794,\n \"negative_logit\": -0.6407562046595957,\n \"pair_accuracy\": 0.7602795423917307,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.22850921400004,\n \"validation_loss\": 0.5048305718913402,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.475705923000078\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7521852254867554,\n \"query_norm_std\": 0.8638167977333069,\n \"item_norm_mean\": 1.8543914556503296,\n \"item_norm_std\": 0.8459439277648926\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.023522,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 1875\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:55:00.048Z",
"resultDisplay": "loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.551810 running_bce=0.544138 elapsed=196.1s\nepoch=1/1 train_loss=0.54212 validation_loss=0.50483 pair_accuracy=0.760 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.2 validation_seconds=15.5\nrestored best validation-BCE checkpoint: epoch=1 loss=0.504831\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.261,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.542115418840845,\n \"positive_logit\": 0.7774311445323794,\n \"negative_logit\": -0.6407562046595957,\n \"pair_accuracy\": 0.7602795423917307,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.22850921400004,\n \"validation_loss\": 0.5048305718913402,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.475705923000078\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7521852254867554,\n \"query_norm_std\": 0.8638167977333069,\n \"item_norm_mean\": 1.8543914556503296,\n \"item_norm_std\": 0.8459439277648926\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.023522,\n \"quality_users\": 4263\n }\n}",
"description": "Test baseline with discovery-graded target weighting",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:55:00.050Z",
"content": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.551810 running_bce=0.544138 elapsed=196.1s\nepoch=1/1 train_loss=0.54212 validation_loss=0.50483 pair_accuracy=0.760 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.2 validation_seconds=15.5\nrestored best validation-BCE checkpoint: epoch=1 loss=0.504831\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.261,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.542115418840845,\n \"positive_logit\": 0.7774311445323794,\n \"negative_logit\": -0.6407562046595957,\n \"pair_accuracy\": 0.7602795423917307,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.22850921400004,\n \"validation_loss\": 0.5048305718913402,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.475705923000078\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7521852254867554,\n \"query_norm_std\": 0.8638167977333069,\n \"item_norm_mean\": 1.8543914556503296,\n \"item_norm_std\": 0.8459439277648926\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp1_discovery_graded.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.023522,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 1875\n",
"isError": false
},
"responseMessageId": "80ff37a2-7aa8-4d0f-8c79-f071c16e6c1f"
}
]
},
{
"id": 38,
"role": "agent",
"timestamp": "2026-09-29T05:55:10.425Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:55:10.425Z",
"text": "Discovering Improved NDCG\n\nI've observed a promising baseline enhancement with `discovery-graded`, pushing NDCG@10 to 0.023522. While this is a good start, my focus is now shifting towards optimizing negative sampling strategies and refining the loss function to further elevate performance beyond the current 0.0235 mark."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:55:10.425Z",
"callId": "run_shell_command__call_50347",
"name": "run_shell_command",
"input": {
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/exp1_discovery_graded.parquet')\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Unique items predicted:', df.item_id.nunique())\nprint('Mean pop rank:', df.pop_rank.mean())\n\"",
"description": "Check distribution of exp1"
},
"recorded": {
"id": "run_shell_command__call_50347",
"name": "run_shell_command",
"args": {
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/exp1_discovery_graded.parquet')\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Unique items predicted:', df.item_id.nunique())\nprint('Mean pop rank:', df.pop_rank.mean())\n\"",
"description": "Check distribution of exp1"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_50347",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Unique items predicted: 2930\nMean pop rank: 3232.9024917218544\nProcess Group PGID: 1962\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:55:12.034Z",
"resultDisplay": "Unique items predicted: 2930\nMean pop rank: 3232.9024917218544",
"description": "Check distribution of exp1",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:55:12.036Z",
"content": "\nOutput: Unique items predicted: 2930\nMean pop rank: 3232.9024917218544\nProcess Group PGID: 1962\n",
"isError": false
},
"responseMessageId": "d419585f-be74-414b-94b2-d7dd13c26119"
}
]
},
{
"id": 39,
"role": "agent",
"timestamp": "2026-09-29T05:55:36.731Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:55:36.731Z",
"text": "Analyzing Loss Function\n\nI'm currently delving into the specifics of InfoNCE and Cross-Entropy loss within `score_target_microbatches`. My focus is on understanding its precise implementation and effect on negative sampling in `/app/solution/train_current_model.py`."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:55:36.731Z",
"text": "Correcting Logits\n\nI'm re-evaluating the logits calculation. It appears I overlooked the necessity of incorporating log-Q, or propensity, corrections when dealing with sampled softmax. My next step is to accurately compute and apply these corrections to the negative logits as per standard practice for sampled softmax."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:55:36.731Z",
"text": "Refining Logit Calculation\n\nI'm realizing the log-Q correction's impact on logits for sampled softmax. It seems subtracting log-Q actually suppresses the scores of popular items, which is precisely what's needed to disentangle true affinity from inherent popularity bias during training. This should lead to more accurate affinity estimations at inference.\n\n**Investigating Negative Sampling**\n\nI'm now examining the sampling strategy for in-batch negatives within `draw_full_history_filtered_neg`. I need to understand if the current method of drawing more in-batch negatives or sampling them proportionally to frequency aligns with the log-Q correction's goal of mitigating popularity bias effectively."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:55:36.731Z",
"text": "Revising Negative Sampling\n\nI've identified a critical flaw: `unique_targets` was previously creating duplicates, leading to uniform, not popularity-weighted, in-batch negative sampling. I'm now rectifying this to ensure more accurate bias mitigation."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:55:36.731Z",
"callId": "run_shell_command__call_71113",
"name": "run_shell_command",
"input": {
"command": "python -c \"\nimport torch\nimport time\nimport sys\nsys.path.insert(0, '/app/solution')\nimport two_tower_model as base\n\ncatalog_features = torch.randn(30000, 4)\nconfig = base.TowerConfig()\nmodel = base.SequentialTwoTower(catalog_features.numpy(), config)\n\nB = 5000\npositives = torch.randint(0, 30000, (B,))\n\nfor K in [32, 64, 128]:\n negatives = torch.randint(0, 30000, (B, K))\n all_items = torch.cat([positives, negatives.reshape(-1)])\n t0 = time.time()\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n pos_vec = encoded[inverse[: len(positives)]]\n neg_vec = encoded[inverse[len(positives) :]].reshape(len(positives), K, -1)\n q = torch.randn(B, 192)\n pos_logits = (q * pos_vec).sum(dim=1)\n neg_logits = torch.einsum('bd,bkd->bk', q, neg_vec)\n t1 = time.time()\n print(f'K={K}: unique_items={len(unique_items)}, time={t1-t0:.4f}s')\n\"",
"description": "Benchmark candidate encoding time vs K"
},
"recorded": {
"id": "run_shell_command__call_71113",
"name": "run_shell_command",
"args": {
"command": "python -c \"\nimport torch\nimport time\nimport sys\nsys.path.insert(0, '/app/solution')\nimport two_tower_model as base\n\ncatalog_features = torch.randn(30000, 4)\nconfig = base.TowerConfig()\nmodel = base.SequentialTwoTower(catalog_features.numpy(), config)\n\nB = 5000\npositives = torch.randint(0, 30000, (B,))\n\nfor K in [32, 64, 128]:\n negatives = torch.randint(0, 30000, (B, K))\n all_items = torch.cat([positives, negatives.reshape(-1)])\n t0 = time.time()\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n pos_vec = encoded[inverse[: len(positives)]]\n neg_vec = encoded[inverse[len(positives) :]].reshape(len(positives), K, -1)\n q = torch.randn(B, 192)\n pos_logits = (q * pos_vec).sum(dim=1)\n neg_logits = torch.einsum('bd,bkd->bk', q, neg_vec)\n t1 = time.time()\n print(f'K={K}: unique_items={len(unique_items)}, time={t1-t0:.4f}s')\n\"",
"description": "Benchmark candidate encoding time vs K"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_71113",
"name": "run_shell_command",
"response": {
"output": "\nOutput: K=32: unique_items=29862, time=0.3472s\nK=64: unique_items=29999, time=0.3962s\nK=128: unique_items=30000, time=0.4619s\nProcess Group PGID: 1981\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:55:42.050Z",
"resultDisplay": "K=32: unique_items=29862, time=0.3472s\nK=64: unique_items=29999, time=0.3962s\nK=128: unique_items=30000, time=0.4619s",
"description": "Benchmark candidate encoding time vs K",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:55:42.051Z",
"content": "\nOutput: K=32: unique_items=29862, time=0.3472s\nK=64: unique_items=29999, time=0.3962s\nK=128: unique_items=30000, time=0.4619s\nProcess Group PGID: 1981\n",
"isError": false
},
"responseMessageId": "ddf5d865-7425-443d-8ef8-852584f5c4e8"
}
]
},
{
"id": 40,
"role": "agent",
"timestamp": "2026-09-29T05:59:39.471Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Exploring Encoding Efficiency\n\nMy recent findings indicate remarkable efficiency even at larger negative sample sizes. With B=5000, increasing K to 128 negatives per target only marginally increases processing time to 0.46s per batch. This suggests promising scalability for candidate encoding and logit generation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Evaluating Loss Functions\n\nMy focus has shifted to comparing BCE with InfoNCE. I'm setting up a test to directly evaluate InfoNCE performance, specifically examining its implementation within `score_target_microbatches` and considering changes to the loss function in `/app/solution/train_current_model.py`."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Refining Loss Calculations\n\nI'm investigating the implementation of InfoNCE loss, specifically exploring how the temperature parameter `tau` should be set by examining typical dot product values from the user and item towers. This aims to optimize the loss function for better model performance."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Investigating Output Normalization\n\nI've observed a lack of LayerNorm or L2-normalization at the output of the user and item towers. This leads to specific norms for query and item vectors, impacting dot products and potentially causing large logit differences with small `tau` values. I'm considering adding normalization."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Analyzing Temperature Scaling\n\nI'm now considering the impact of different temperature (`tau`) values, exploring options like 0.1, 0.2, and 0.5, and whether it should be learnable or a CLI argument. My attention is also turning to the core negative sampling strategy itself, specifically how it selects and utilizes these examples to identify potential limitations."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Examining Negative Sampling\n\nI'm now scrutinizing the exact methodology for selecting negative examples, specifically diving into the `draw_full_history_filtered_negatives` function. I'm analyzing how uniform and in-batch negatives are drawn and filtered, paying close attention to how known positives are excluded."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Refining Negative Sampling Logic\n\nI'm now focused on the precise implementation of `draw_full_history_filtered_negatives`. I've been examining how unique targets are handled to ensure the correct count of in-batch negatives, and I'm scrutinizing the logic for filling remaining negative slots with random items when necessary."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Clarifying Negative Sampling Weighting\n\nI'm analyzing the `draw_full_history_filtered_negatives` function's use of `torch.unique(targets)`. This deduplication means popular items have an equal chance of being selected as negatives as unpopular ones, potentially hindering the model's ability to learn to avoid recommending overly popular items."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T05:59:39.471Z",
"text": "Investigating Sampling Probabilities\n\nI'm re-evaluating how in-batch negatives are sampled. If sampled proportionally from `targets_cpu`, tracks appearing frequently as positives would also appear more frequently as negatives, creating a more balanced learning signal than uniform random sampling. This could significantly impact how effectively the model learns to distinguish between relevant and irrelevant items."
},
{
"kind": "tool",
"timestamp": "2026-09-29T05:59:39.471Z",
"callId": "run_shell_command__call_5349308",
"name": "run_shell_command",
"input": {
"description": "Inspect train_dislikes.parquet",
"command": "python -c \"\nimport pandas as pd\ndislikes = pd.read_parquet('/task/data/train_dislikes.parquet')\nprint('Dislikes shape:', dislikes.shape)\nprint('Unique users with dislikes:', dislikes.uid.nunique())\nprint('Unique items disliked:', dislikes.item_id.nunique())\nprint(dislikes.head(5))\n\""
},
"recorded": {
"id": "run_shell_command__call_5349308",
"name": "run_shell_command",
"args": {
"description": "Inspect train_dislikes.parquet",
"command": "python -c \"\nimport pandas as pd\ndislikes = pd.read_parquet('/task/data/train_dislikes.parquet')\nprint('Dislikes shape:', dislikes.shape)\nprint('Unique users with dislikes:', dislikes.uid.nunique())\nprint('Unique items disliked:', dislikes.item_id.nunique())\nprint(dislikes.head(5))\n\""
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_5349308",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Dislikes shape: (101075, 4)\nUnique users with dislikes: 5732\nUnique items disliked: 50876\n uid timestamp item_id is_organic\n0 100 3087560 9170134 1\n1 100 3936560 8661238 1\n2 100 20432825 4927727 1\n3 400 2980800 399811 1\n4 400 3157520 1575108 1\nProcess Group PGID: 2025\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T05:59:41.018Z",
"resultDisplay": "Dislikes shape: (101075, 4)\nUnique users with dislikes: 5732\nUnique items disliked: 50876\n uid timestamp item_id is_organic\n0 100 3087560 9170134 1\n1 100 3936560 8661238 1\n2 100 20432825 4927727 1\n3 400 2980800 399811 1\n4 400 3157520 1575108 1",
"description": "Inspect train_dislikes.parquet",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T05:59:41.020Z",
"content": "\nOutput: Dislikes shape: (101075, 4)\nUnique users with dislikes: 5732\nUnique items disliked: 50876\n uid timestamp item_id is_organic\n0 100 3087560 9170134 1\n1 100 3936560 8661238 1\n2 100 20432825 4927727 1\n3 400 2980800 399811 1\n4 400 3157520 1575108 1\nProcess Group PGID: 2025\n",
"isError": false
},
"responseMessageId": "e72af71c-9f40-49a3-b56f-232d797933ce"
}
]
},
{
"id": 41,
"role": "agent",
"timestamp": "2026-09-29T06:01:46.504Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Analyzing Dislike Distribution\n\nI'm currently digging into the dislike data. It appears dislikes aren't evenly spread, with a concentration in certain areas, suggesting issues beyond individual user preferences, like catalog or popularity-driven negatives. I'm also examining item correction data to understand its relationship."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Investigating _negative_loss_\n\nI'm revisiting the `_negative_loss` calculation, specifically focusing on the `build_item_correction` function. My current line of inquiry is into how the item correction probabilities are derived from the observed counts and the total number of items, aiming to pinpoint potential issues in this formulation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Refining Propensity Calculation\n\nI'm scrutinizing how in-batch propensities are computed. Specifically, I'm analyzing the relationship between item target counts, total items, and the `inbatch_correction_power` parameter in the `build_item_correction` function to understand its impact on the resulting `raw` values."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Adjusting Logit Weighting\n\nI'm realizing the baseline's multiplication of BCE loss with a correction factor amplifies issues. Popular items get their negative loss reduced, while rare items see it drastically increased, a stark contrast to the logit adjustment in sampled softmax, which I now understand significantly alters item influence."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Correcting Sampling Misinterpretation\n\nI've discovered a critical conceptual inversion. The baseline incorrectly multiplied negative loss by a correction factor derived from sampling probability ($1/Q_i$), instead of applying it to the logit as in Google's paper. This significantly altered item influence, contrary to importance sampling principles."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Revising Loss Calculation\n\nI'm rethinking the loss function's core. It appears uniform sampling was applied instead of proportional, and the negative loss was normalized incorrectly. Downweighting popular items as negatives is problematic, as they're the hardest to differentiate, leading to models favoring them universally."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Implementing InfoNCE Loss\n\nI'm now focused on integrating the InfoNCE loss. My plan is to first test this in a small prototype script to verify the mechanics before implementing it directly within `train_current_model.py`, ensuring correct calculation of logits for both positive and negative items."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Integrating InfoNCE Components\n\nI'm now thoroughly examining the integration of InfoNCE loss components. My immediate focus is on how `pair_correct` and statistics within `score_target_microbatches` interact with the calculated `loss_sum`, `positive_sum`, `negative_sum`, and `weight_sum`, and I'm cross-referencing this with `evaluate_validation_bce` to ensure all facets are accounted for."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Adjusting Temperature Scaling\n\nI'm currently exploring the impact of the temperature parameter $\\tau$ on the InfoNCE loss. Varying its value significantly alters gradients, and I'm investigating optimal ranges, considering scenarios from strong positive/negative separation to near-equal scores, to ensure effective model training."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Sampling Negatives Differently\n\nI'm rethinking how negatives are sampled within batches. Instead of uniform random priorities from unique targets, I'm considering sampling directly from the batch targets or proportionally to catalog popularity. This might offer a more nuanced approach to selecting informative negatives."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:01:46.504Z",
"text": "Optimizing Negative Sampling\n\nI've discovered a highly efficient method for in-batch negative sampling that directly leverages batch frequency, bypassing costly operations. I'm now testing variations in the number of in-batch versus uniform negatives and will proceed to experiment with replacing BCE loss with InfoNCE loss using a $\\tau$ of 0.1."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:01:46.504Z",
"callId": "read_file__call_231761",
"name": "read_file",
"input": {
"start_line": 1140,
"file_path": "/app/solution/train_current_model.py",
"end_line": 1210
},
"recorded": {
"id": "read_file__call_231761",
"name": "read_file",
"args": {
"start_line": 1140,
"file_path": "/app/solution/train_current_model.py",
"end_line": 1210
},
"result": [
{
"functionResponse": {
"id": "read_file__call_231761",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1140-1210 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1211.\n\n--- FILE CONTENT (truncated) ---\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:01:46.510Z",
"resultDisplay": "Read lines 1140-1210 of 2165 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:01:46.511Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1140-1210 of 2165 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1211.\n\n--- FILE CONTENT (truncated) ---\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,",
"isError": false
},
"responseMessageId": "7d95a8cb-d738-4b72-b792-94ee1a881965"
}
]
},
{
"id": 42,
"role": "agent",
"timestamp": "2026-09-29T06:04:35.020Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:04:35.020Z",
"text": "Refining Loss Configuration\n\nI'm considering adding `loss_type` and `temperature` to the `Config` dataclass to allow for flexible loss function selection and temperature scaling. My next step is to trace all instances of `Config` usage within the `train_current_model.py` script to ensure seamless integration."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:04:35.020Z",
"text": "Integrating Loss Parameters\n\nI've confirmed that the existing validation cache will remain valid as the new loss-related `Config` parameters aren't serialized there. My focus is now on verifying how `score_target_microbatches` uses these new parameters, ensuring smooth functionality."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:04:35.020Z",
"callId": "replace__call_157302",
"name": "replace",
"input": {
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"new_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25",
"old_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25",
"instruction": "Add loss_type and temperature to Config and implement InfoNCE loss in score_target_microbatches"
},
"recorded": {
"id": "replace__call_157302",
"name": "replace",
"args": {
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"new_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25",
"old_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25",
"instruction": "Add loss_type and temperature to Config and implement InfoNCE loss in score_target_microbatches"
},
"result": [
{
"functionResponse": {
"id": "replace__call_157302",
"name": "replace",
"response": {
"error": "EACCES: permission denied, open '/app/solution/train_current_model.py'"
}
}
}
],
"status": "error",
"timestamp": "2026-09-29T06:04:35.027Z",
"resultDisplay": "Error writing file: EACCES: permission denied, open '/app/solution/train_current_model.py'",
"description": "Replaces text within a file. By default, the tool expects to find and replace exactly ONE occurrence of `old_string`. If you want to replace multiple occurrences of the exact same string, set `allow_multiple` to true. This tool requires providing significant context around the change to ensure precise targeting. Always use the read_file tool to examine the file's current content before attempting a text replacement.\n \n The user has the ability to modify the `new_string` content. If modified, this will be stated in the response.\n \n Expectation for required parameters:\n 1. `old_string` MUST be the exact literal text to replace (including all whitespace, indentation, newlines, and surrounding code etc.).\n 2. `new_string` MUST be the exact literal text to replace `old_string` with (also including all whitespace, indentation, newlines, and surrounding code etc.). Ensure the resulting code is correct and idiomatic and that `old_string` and `new_string` are different.\n 3. `instruction` is the detailed instruction of what needs to be changed. It is important to Make it specific and detailed so developers or large language models can understand what needs to be changed and perform the changes on their own if necessary. \n 4. NEVER escape `old_string` or `new_string`, that would break the exact literal text requirement.\n **Important:** If ANY of the above are not satisfied, the tool will fail. CRITICAL for `old_string`: Must uniquely identify the instance(s) to change. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. If this string matches multiple locations and `allow_multiple` is not true, the tool will fail.\n 5. Prefer to break down complex and long changes into multiple smaller atomic calls to this tool. Always check the content of the file after changes or not finding a string to match.\n **Multiple replacements:** Set `allow_multiple` to true if you want to replace ALL occurrences that match `old_string` exactly.",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:04:35.029Z",
"content": "EACCES: permission denied, open '/app/solution/train_current_model.py'",
"isError": true
},
"responseMessageId": "82c7085e-3804-4e15-8b9d-5ff89224d560"
}
]
},
{
"id": 43,
"role": "agent",
"timestamp": "2026-09-29T06:04:43.669Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:04:43.669Z",
"callId": "run_shell_command__call_40149",
"name": "run_shell_command",
"input": {
"command": "ls -la /app/solution",
"description": "Check permissions in /app/solution"
},
"recorded": {
"id": "run_shell_command__call_40149",
"name": "run_shell_command",
"args": {
"command": "ls -la /app/solution",
"description": "Check permissions in /app/solution"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_40149",
"name": "run_shell_command",
"response": {
"output": "\nOutput: total 525228\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:54 .\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:33 ..\n-rw-r--r-- 1 agent agent 1249069 Sep 29 05:54 exp1_discovery_graded.parquet\n-rw-r--r-- 1 agent agent 1244230 Sep 29 05:43 production_validation.parquet\n-r--r--r-- 1 agent agent 80058 Sep 29 05:49 train_current_model.py\n-r--r--r-- 1 agent agent 15985 Sep 29 05:49 two_tower_model.py\n-rw-r--r-- 1 agent agent 535225808 Sep 29 05:38 validation_cache.npz\nProcess Group PGID: 2072\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:04:43.686Z",
"resultDisplay": "total 525228\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:54 .\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:33 ..\n-rw-r--r-- 1 agent agent 1249069 Sep 29 05:54 exp1_discovery_graded.parquet\n-rw-r--r-- 1 agent agent 1244230 Sep 29 05:43 production_validation.parquet\n-r--r--r-- 1 agent agent 80058 Sep 29 05:49 train_current_model.py\n-r--r--r-- 1 agent agent 15985 Sep 29 05:49 two_tower_model.py\n-rw-r--r-- 1 agent agent 535225808 Sep 29 05:38 validation_cache.npz",
"description": "ls -la /app/solution",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:04:43.688Z",
"content": "\nOutput: total 525228\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:54 .\ndrwxr-xr-x 1 agent agent 4096 Sep 29 05:33 ..\n-rw-r--r-- 1 agent agent 1249069 Sep 29 05:54 exp1_discovery_graded.parquet\n-rw-r--r-- 1 agent agent 1244230 Sep 29 05:43 production_validation.parquet\n-r--r--r-- 1 agent agent 80058 Sep 29 05:49 train_current_model.py\n-r--r--r-- 1 agent agent 15985 Sep 29 05:49 two_tower_model.py\n-rw-r--r-- 1 agent agent 535225808 Sep 29 05:38 validation_cache.npz\nProcess Group PGID: 2072\n",
"isError": false
},
"responseMessageId": "54f1956f-22e2-4b80-b9ee-e40edbf8ac6d"
}
]
},
{
"id": 44,
"role": "agent",
"timestamp": "2026-09-29T06:04:47.317Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:04:47.317Z",
"callId": "run_shell_command__call_49154",
"name": "run_shell_command",
"input": {
"command": "chmod u+w /app/solution/train_current_model.py /app/solution/two_tower_model.py",
"description": "Make copied scripts writable in /app/solution"
},
"recorded": {
"id": "run_shell_command__call_49154",
"name": "run_shell_command",
"args": {
"command": "chmod u+w /app/solution/train_current_model.py /app/solution/two_tower_model.py",
"description": "Make copied scripts writable in /app/solution"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_49154",
"name": "run_shell_command",
"response": {
"output": "\nOutput: (empty)\nProcess Group PGID: 2075\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:04:47.333Z",
"resultDisplay": "",
"description": "chmod u+w /app/solution/train_current_model.py /app/solution/two_tower_model.py",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:04:47.335Z",
"content": "\nOutput: (empty)\nProcess Group PGID: 2075\n",
"isError": false
},
"responseMessageId": "6901e623-9617-44d6-a38e-c15198f590e0"
}
]
},
{
"id": 45,
"role": "agent",
"timestamp": "2026-09-29T06:05:03.781Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:03.781Z",
"callId": "replace__call_3433081",
"name": "replace",
"input": {
"new_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25",
"file_path": "/app/solution/train_current_model.py",
"instruction": "Add loss_type and temperature to Config",
"old_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25",
"allow_multiple": false
},
"recorded": {
"id": "replace__call_3433081",
"name": "replace",
"args": {
"new_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25",
"file_path": "/app/solution/train_current_model.py",
"instruction": "Add loss_type and temperature to Config",
"old_string": " negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25",
"allow_multiple": false
},
"result": [
{
"functionResponse": {
"id": "replace__call_3433081",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:03.799Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -60,6 +60,8 @@\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n+ loss_type: str = \"infonce\"\n+ temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 2,
"model_removed_lines": 0,
"model_added_chars": 58,
"model_removed_chars": 0,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: negative_filter_scope: str... => negative_filter_scope: str...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:03.802Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n...",
"isError": false
},
"responseMessageId": "76b8ab44-6d8d-48ed-a573-6b0c8b94f9aa"
}
]
},
{
"id": 46,
"role": "agent",
"timestamp": "2026-09-29T06:05:07.606Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:07.606Z",
"callId": "read_file__call_63823",
"name": "read_file",
"input": {
"file_path": "/app/solution/train_current_model.py",
"end_line": 1195,
"start_line": 1165
},
"recorded": {
"id": "read_file__call_63823",
"name": "read_file",
"args": {
"file_path": "/app/solution/train_current_model.py",
"end_line": 1195,
"start_line": 1165
},
"result": [
{
"functionResponse": {
"id": "read_file__call_63823",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1165-1195 of 2167 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1196.\n\n--- FILE CONTENT (truncated) ---\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:07.611Z",
"resultDisplay": "Read lines 1165-1195 of 2167 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:08.908Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1165-1195 of 2167 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 1196.\n\n--- FILE CONTENT (truncated) ---\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )",
"isError": false
},
"responseMessageId": "aaf1ca77-a880-4e94-8377-fe16ae9fee9b"
}
]
},
{
"id": 47,
"role": "agent",
"timestamp": "2026-09-29T06:05:13.335Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:13.335Z",
"callId": "read_file__call_7350148",
"name": "read_file",
"input": {
"file_path": "/app/solution/train_current_model.py",
"end_line": 2050,
"start_line": 1950
},
"recorded": {
"id": "read_file__call_7350148",
"name": "read_file",
"args": {
"file_path": "/app/solution/train_current_model.py",
"end_line": 2050,
"start_line": 1950
},
"result": [
{
"functionResponse": {
"id": "read_file__call_7350148",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1950-2050 of 2167 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2051.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:13.340Z",
"resultDisplay": "Read lines 1950-2050 of 2167 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:13.341Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1950-2050 of 2167 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2051.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)",
"isError": false
},
"responseMessageId": "c4c25043-9787-4dee-92cf-5943cee6a324"
}
]
},
{
"id": 48,
"role": "agent",
"timestamp": "2026-09-29T06:05:18.941Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:05:18.941Z",
"text": "Implementing Configuration Options\n\nI'm currently focused on integrating new command-line arguments, specifically `--loss-type` and `--temperature`, into our argument parser. These will then be supported within the `Config` object. My immediate priority is updating the `score_target_microbatches` functionality to accommodate these changes."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:18.941Z",
"callId": "replace__call_234754",
"name": "replace",
"input": {
"new_string": " positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()",
"instruction": "Compute InfoNCE loss when config.loss_type == 'infonce' in score_target_microbatches",
"old_string": " positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false
},
"recorded": {
"id": "replace__call_234754",
"name": "replace",
"args": {
"new_string": " positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()",
"instruction": "Compute InfoNCE loss when config.loss_type == 'infonce' in score_target_microbatches",
"old_string": " positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false
},
"result": [
{
"functionResponse": {
"id": "replace__call_234754",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:18.957Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -1170,16 +1170,23 @@\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n- positive_loss = F.softplus(-positive_logits)\n- negative_loss = corrected_negative_loss(\n- negative_logits, negative_weights[begin:end], config\n- )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n- loss_sum = (\n- selected_weights * (positive_loss + negative_loss) / 2.0\n- ).sum()\n+ if config.loss_type == \"infonce\":\n+ all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n+ scaled_logits = all_logits / config.temperature\n+ targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n+ sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n+ loss_sum = (selected_weights * sample_loss).sum()\n+ else:\n+ positive_loss = F.softplus(-positive_logits)\n+ negative_loss = corrected_negative_loss(\n+ negative_logits, negative_weights[begin:end], config\n+ )\n+ loss_sum = (\n+ selected_weights * (positive_loss + negative_loss) / 2.0\n+ ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 14,
"model_removed_lines": 7,
"model_added_chars": 747,
"model_removed_chars": 276,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: positive_logits = (que... => positive_logits = (que...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:18.959Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n...",
"isError": false
},
"responseMessageId": "d56bf70e-640e-4949-935f-bbc3071da860"
}
]
},
{
"id": 49,
"role": "agent",
"timestamp": "2026-09-29T06:05:26.722Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:26.722Z",
"callId": "replace__call_5545247",
"name": "replace",
"input": {
"new_string": " parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )",
"instruction": "Add --loss-type and --temperature arguments to main()",
"old_string": " parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )",
"allow_multiple": false,
"file_path": "/app/solution/train_current_model.py"
},
"recorded": {
"id": "replace__call_5545247",
"name": "replace",
"args": {
"new_string": " parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )",
"instruction": "Add --loss-type and --temperature arguments to main()",
"old_string": " parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )",
"allow_multiple": false,
"file_path": "/app/solution/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "replace__call_5545247",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:26.737Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -1960,6 +1960,16 @@\n default=Config.target_weighting,\n )\n parser.add_argument(\n+ \"--loss-type\",\n+ choices=(\"infonce\", \"bce\"),\n+ default=Config.loss_type,\n+ )\n+ parser.add_argument(\n+ \"--temperature\",\n+ type=float,\n+ default=Config.temperature,\n+ )\n+ parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 10,
"model_removed_lines": 0,
"model_added_chars": 226,
"model_removed_chars": 0,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: parser.add_argument(... => parser.add_argument(...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:26.740Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n...",
"isError": false
},
"responseMessageId": "f7814d5e-8d81-4645-a0c8-f9d8028081ab"
}
]
},
{
"id": 50,
"role": "agent",
"timestamp": "2026-09-29T06:05:30.090Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:30.090Z",
"callId": "read_file__call_232776",
"name": "read_file",
"input": {
"end_line": 2070,
"file_path": "/app/solution/train_current_model.py",
"start_line": 2040
},
"recorded": {
"id": "read_file__call_232776",
"name": "read_file",
"args": {
"end_line": 2070,
"file_path": "/app/solution/train_current_model.py",
"start_line": 2040
},
"result": [
{
"functionResponse": {
"id": "read_file__call_232776",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2040-2070 of 2184 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2071.\n\n--- FILE CONTENT (truncated) ---\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:30.095Z",
"resultDisplay": "Read lines 2040-2070 of 2184 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:30.096Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2040-2070 of 2184 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2071.\n\n--- FILE CONTENT (truncated) ---\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():",
"isError": false
},
"responseMessageId": "126d5196-fb85-4377-8ef1-982a841fc459"
}
]
},
{
"id": 51,
"role": "agent",
"timestamp": "2026-09-29T06:05:34.574Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:34.574Z",
"callId": "replace__call_4616986",
"name": "replace",
"input": {
"new_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,",
"old_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"instruction": "Pass loss_type and temperature to Config in main()"
},
"recorded": {
"id": "replace__call_4616986",
"name": "replace",
"args": {
"new_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,",
"old_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"instruction": "Pass loss_type and temperature to Config in main()"
},
"result": [
{
"functionResponse": {
"id": "replace__call_4616986",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:05:34.587Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -2052,6 +2052,8 @@\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n+ loss_type=args.loss_type,\n+ temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 2,
"model_removed_lines": 0,
"model_added_chars": 70,
"model_removed_chars": 0,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: negative_filter_scope=... => negative_filter_scope=...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:05:34.589Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n...",
"isError": false
},
"responseMessageId": "137fa5c3-f359-45fa-9d6f-a8ba5a961563"
}
]
},
{
"id": 52,
"role": "agent",
"timestamp": "2026-09-29T06:05:41.078Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:05:41.078Z",
"text": "Checking model imports\n\nI'm examining `train_current_model.py` to confirm where the `two_tower_model` is being sourced from. It appears to be imported as `base`, and I'm currently verifying the exact path it's referencing."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:05:41.078Z",
"callId": "run_shell_command__call_84968",
"name": "run_shell_command",
"input": {
"description": "Run experiment with InfoNCE loss (tau=0.1) and evaluate",
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type infonce \\\n --temperature 0.1 \\\n --output /app/solution/exp2_infonce_01.parquet && \\\npython /task/evaluate_public.py /app/solution/exp2_infonce_01.parquet"
},
"recorded": {
"id": "run_shell_command__call_84968",
"name": "run_shell_command",
"args": {
"description": "Run experiment with InfoNCE loss (tau=0.1) and evaluate",
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type infonce \\\n --temperature 0.1 \\\n --output /app/solution/exp2_infonce_01.parquet && \\\npython /task/evaluate_public.py /app/solution/exp2_infonce_01.parquet"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_84968",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=2.882234 running_bce=2.888013 elapsed=196.7s\nepoch=1/1 train_loss=2.87533 validation_loss=2.66998 pair_accuracy=0.775 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.7 validation_seconds=15.8\nrestored best validation-BCE checkpoint: epoch=1 loss=2.669981\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp2_infonce_01.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.706,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"infonce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 2.8753293551465733,\n \"positive_logit\": 0.013731765006966084,\n \"negative_logit\": -0.1270103591336814,\n \"pair_accuracy\": 0.7748257460209526,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.6856498139996,\n \"validation_loss\": 2.669981021485753,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.780993051999758\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 0.6981536149978638,\n \"query_norm_std\": 0.19272513687610626,\n \"item_norm_mean\": 0.8023920655250549,\n \"item_norm_std\": 0.17788256704807281\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp2_infonce_01.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.018216,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2084\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:11:05.424Z",
"resultDisplay": "loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=2.882234 running_bce=2.888013 elapsed=196.7s\nepoch=1/1 train_loss=2.87533 validation_loss=2.66998 pair_accuracy=0.775 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.7 validation_seconds=15.8\nrestored best validation-BCE checkpoint: epoch=1 loss=2.669981\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp2_infonce_01.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.706,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"infonce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 2.8753293551465733,\n \"positive_logit\": 0.013731765006966084,\n \"negative_logit\": -0.1270103591336814,\n \"pair_accuracy\": 0.7748257460209526,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.6856498139996,\n \"validation_loss\": 2.669981021485753,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.780993051999758\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 0.6981536149978638,\n \"query_norm_std\": 0.19272513687610626,\n \"item_norm_mean\": 0.8023920655250549,\n \"item_norm_std\": 0.17788256704807281\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp2_infonce_01.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.018216,\n \"quality_users\": 4263\n }\n}",
"description": "Run experiment with InfoNCE loss (tau=0.1) and evaluate",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:11:05.426Z",
"content": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=2.882234 running_bce=2.888013 elapsed=196.7s\nepoch=1/1 train_loss=2.87533 validation_loss=2.66998 pair_accuracy=0.775 train_targets=1,052,953 validation_targets=130,103 train_seconds=209.7 validation_seconds=15.8\nrestored best validation-BCE checkpoint: epoch=1 loss=2.669981\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp2_infonce_01.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 316.706,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"infonce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 2.8753293551465733,\n \"positive_logit\": 0.013731765006966084,\n \"negative_logit\": -0.1270103591336814,\n \"pair_accuracy\": 0.7748257460209526,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 209.6856498139996,\n \"validation_loss\": 2.669981021485753,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.780993051999758\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 0.6981536149978638,\n \"query_norm_std\": 0.19272513687610626,\n \"item_norm_mean\": 0.8023920655250549,\n \"item_norm_std\": 0.17788256704807281\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp2_infonce_01.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.018216,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2084\n",
"isError": false
},
"responseMessageId": "fa336619-be84-4d99-bec2-fca16560f1b9"
}
]
},
{
"id": 53,
"role": "agent",
"timestamp": "2026-09-29T06:22:48.005Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Investigating Temperature Effects\n\nI'm analyzing the significant performance drop observed with InfoNCE at $\\tau = 0.1$. My current focus is understanding why the norms of the query and item embeddings appear to have shrunk, which seems correlated with the decreased score. I'm examining the associated logits for further clues."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Revisiting Training Objectives\n\nI'm re-evaluating the training objectives, specifically why BCE is outperforming InfoNCE. The recent insight suggests the temperature scaling in InfoNCE might be causing gradient issues, leading to embedding shrinkage, which then impacts performance. I'm now focused on dissecting this interaction."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Analyzing Negative Sampling\n\nMy focus has shifted to understanding precisely how the current trainer selects and utilizes negative examples within its training objective. I'm meticulously examining functions like `build_item_correction`, `draw_full_history_filtered_negatives`, and `draw_training_negatives` to diagnose limitations in the current negative-sampling strategy. The goal is to propose improvements that fit within the established CPU budget."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Exploring In-Batch Correction\n\nI'm now scrutinizing the `build_item_correction` function. My goal is to understand how it estimates in-batch propensities by analyzing its use of `target_counts` and `prepared.sequence_items`. I'm particularly interested in the calculation of `probabilities` and the subsequent `raw` power transformation, aiming to link this to potential training objective impacts."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Investigating Correction Calculations\n\nI'm examining the `build_item_correction` function, specifically its normalization and clipping steps. I'm also looking into how `draw_full_history_filtered_negatives` handles known positives to ensure sampling efficiency."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Refining Negative Sampling\n\nI'm diving deeper into the negative sampling logic, specifically how the code prioritizes and selects in-batch negatives based on randomness and avoidance of true positives. This detailed analysis aims to optimize efficiency and effectiveness within the existing CPU constraints."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Refining Negative Sampling Strategies\n\nI'm analyzing the logic for generating negative samples, specifically how it incorporates both uniform and in-batch negatives, and then applies corrections. My current focus is on how the code handles filling remaining negative slots when in-batch negatives are insufficient and how it addresses invalid samples."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Analyzing Correction Application\n\nI'm examining how the system handles rejected in-batch negatives by replacing them with uniform draws and resetting their correction factor. I'm also looking at the `corrected_negative_loss` function to understand how it applies these corrections to the softplus output, aiming to pinpoint potential issues in the loss calculation."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Revisiting Loss Calculation\n\nI'm re-examining the `corrected_negative_loss` function and specifically the `weights` variable. It appears `weights` is being set to `correction[:, selected]`, which is then used to weight the `raw` values, where `raw` is actually the output of `F.softplus`. This suggests a potential misunderstanding of how corrections are being applied."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Adjusting Loss Weighting\n\nI've discovered an inversion in how corrections are applied within the `corrected_negative_loss` function. It appears the calculated correction factors are being used as weights, but in a manner that amplifies the loss for less popular items and diminishes it for popular ones, contrary to the intended effect."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Revising Weighting Logic\n\nI'm reassessing the loss weighting within the `corrected_negative_loss` function. The observation suggests an inversion where less popular items are amplified and popular ones diminished, contrary to the goal of propensity weighting. My focus is on correcting this to align with the intended inverse relationship between item popularity and weight."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:22:48.005Z",
"text": "Correcting Loss Inversion\n\nI've identified a critical inversion in how loss is weighted. Instead of downweighting popular items when they're sampled as negatives, the current logic amplifies them. My immediate focus is to invert this weighting mechanism to correctly penalize popular items in negative samples, aligning with the intent of in-batch correction."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:22:48.005Z",
"callId": "replace__call_5364893",
"name": "replace",
"input": {
"new_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)",
"allow_multiple": false,
"old_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total",
"instruction": "Set loss_type default to bce and test unweighted negative loss in corrected_negative_loss",
"file_path": "/app/solution/train_current_model.py"
},
"recorded": {
"id": "replace__call_5364893",
"name": "replace",
"args": {
"new_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)",
"allow_multiple": false,
"old_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total",
"instruction": "Set loss_type default to bce and test unweighted negative loss in corrected_negative_loss",
"file_path": "/app/solution/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "replace__call_5364893",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:22:48.019Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -850,20 +850,7 @@\n config: Config,\n ) -> torch.Tensor:\n raw = F.softplus(logits)\n- total = config.uniform_negatives + config.inbatch_negatives\n- result = torch.zeros(len(logits), device=logits.device)\n- if config.uniform_negatives:\n- result += config.uniform_negatives * raw[\n- :, : config.uniform_negatives\n- ].mean(dim=1)\n- if config.inbatch_negatives:\n- selected = slice(config.uniform_negatives, total)\n- weights = correction[:, selected]\n- result += config.inbatch_negatives * (\n- (raw[:, selected] * weights).sum(dim=1)\n- / weights.sum(dim=1).clamp_min(1.0e-6)\n- )\n- return result / total\n+ return raw.mean(dim=1)\n \n \n def retained_target_window_starts(\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 1,
"model_removed_lines": 14,
"model_added_chars": 26,
"model_removed_chars": 576,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: def corrected_negative_loss(... => def corrected_negative_loss(...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:22:48.022Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n...",
"isError": false
},
"responseMessageId": "a01da5c9-25dc-47e4-8c65-2c3ffd0db76a"
}
]
},
{
"id": 54,
"role": "agent",
"timestamp": "2026-09-29T06:22:52.495Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:22:52.495Z",
"callId": "run_shell_command__call_244481",
"name": "run_shell_command",
"input": {
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type bce \\\n --output /app/solution/exp3_bce_unweighted.parquet && \\\npython /task/evaluate_public.py /app/solution/exp3_bce_unweighted.parquet",
"description": "Run experiment with unweighted negative BCE loss"
},
"recorded": {
"id": "run_shell_command__call_244481",
"name": "run_shell_command",
"args": {
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type bce \\\n --output /app/solution/exp3_bce_unweighted.parquet && \\\npython /task/evaluate_public.py /app/solution/exp3_bce_unweighted.parquet",
"description": "Run experiment with unweighted negative BCE loss"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_244481",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.563095 running_bce=0.563300 elapsed=198.1s\nepoch=1/1 train_loss=0.56103 validation_loss=0.52015 pair_accuracy=0.763 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.1 validation_seconds=15.2\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520147\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 320.086,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5610289522722313,\n \"positive_logit\": 0.6264490667548376,\n \"negative_logit\": -0.6609028545055078,\n \"pair_accuracy\": 0.7632027201119138,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 211.13066360600033,\n \"validation_loss\": 0.5201468392721145,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.211160614000164\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.8937625885009766,\n \"query_norm_std\": 0.849906325340271,\n \"item_norm_mean\": 1.7925578355789185,\n \"item_norm_std\": 0.7955362796783447\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.015049,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2227\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:28:20.267Z",
"resultDisplay": "loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.563095 running_bce=0.563300 elapsed=198.1s\nepoch=1/1 train_loss=0.56103 validation_loss=0.52015 pair_accuracy=0.763 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.1 validation_seconds=15.2\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520147\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 320.086,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5610289522722313,\n \"positive_logit\": 0.6264490667548376,\n \"negative_logit\": -0.6609028545055078,\n \"pair_accuracy\": 0.7632027201119138,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 211.13066360600033,\n \"validation_loss\": 0.5201468392721145,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.211160614000164\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.8937625885009766,\n \"query_norm_std\": 0.849906325340271,\n \"item_norm_mean\": 1.7925578355789185,\n \"item_norm_std\": 0.7955362796783447\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.015049,\n \"quality_users\": 4263\n }\n}",
"description": "Run experiment with unweighted negative BCE loss",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:28:20.269Z",
"content": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.563095 running_bce=0.563300 elapsed=198.1s\nepoch=1/1 train_loss=0.56103 validation_loss=0.52015 pair_accuracy=0.763 train_targets=1,052,953 validation_targets=130,103 train_seconds=211.1 validation_seconds=15.2\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520147\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 320.086,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 24,\n \"inbatch_negatives\": 8,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5610289522722313,\n \"positive_logit\": 0.6264490667548376,\n \"negative_logit\": -0.6609028545055078,\n \"pair_accuracy\": 0.7632027201119138,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 211.13066360600033,\n \"validation_loss\": 0.5201468392721145,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 15.211160614000164\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.8937625885009766,\n \"query_norm_std\": 0.849906325340271,\n \"item_norm_mean\": 1.7925578355789185,\n \"item_norm_std\": 0.7955362796783447\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp3_bce_unweighted.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.015049,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2227\n",
"isError": false
},
"responseMessageId": "d421a4de-d5df-4dd6-b535-dc4abf093f0b"
}
]
},
{
"id": 55,
"role": "agent",
"timestamp": "2026-09-29T06:29:55.860Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:29:55.860Z",
"text": "Analyzing Score Drop\n\nMy current focus is understanding the significant score drop observed after implementing `raw.mean(dim=1)`. I'm investigating the internal mechanisms of `corrected_negative_loss` and how the `correction` and `weights` are being affected by this change, as this seems to be the root cause of the performance degradation."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:29:55.860Z",
"callId": "run_shell_command__call_69667",
"name": "run_shell_command",
"input": {
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/exp3_bce_unweighted.parquet')\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Unique items predicted:', df.item_id.nunique())\nprint('Mean pop rank:', df.pop_rank.mean())\n\"",
"description": "Check distribution of exp3"
},
"recorded": {
"id": "run_shell_command__call_69667",
"name": "run_shell_command",
"args": {
"command": "python -c \"\nimport pandas as pd\ndf = pd.read_parquet('/app/solution/exp3_bce_unweighted.parquet')\ncatalog = pd.read_parquet('/task/data/candidate_catalog.parquet')\ncat_map = dict(zip(catalog.item_id, catalog.popularity_rank))\ndf['pop_rank'] = df.item_id.map(cat_map)\nprint('Unique items predicted:', df.item_id.nunique())\nprint('Mean pop rank:', df.pop_rank.mean())\n\"",
"description": "Check distribution of exp3"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_69667",
"name": "run_shell_command",
"response": {
"output": "\nOutput: Unique items predicted: 3066\nMean pop rank: 3535.2990444654683\nProcess Group PGID: 2317\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:29:57.471Z",
"resultDisplay": "Unique items predicted: 3066\nMean pop rank: 3535.2990444654683",
"description": "Check distribution of exp3",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:29:57.474Z",
"content": "\nOutput: Unique items predicted: 3066\nMean pop rank: 3535.2990444654683\nProcess Group PGID: 2317\n",
"isError": false
},
"responseMessageId": "6896e390-90be-4796-90ce-eb2e881d88be"
}
]
},
{
"id": 56,
"role": "agent",
"timestamp": "2026-09-29T06:30:16.167Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Analyzing Correction Logic\n\nI'm currently delving into the rationale behind the `correction` mechanism. My focus is on scrutinizing the `build_item_correction` function to understand its specific role in shaping the probability calculations."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Refining Correction Logic\n\nI'm currently examining how the `build_item_correction` function impacts probability calculations, specifically focusing on the `raw` values. I'm also investigating the implications of different `inbatch_correction_power` values and how they interact with the `counts` derived from selected training targets."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Investigating Negative Sampling\n\nI'm exploring the implications of varying `uniform_negatives` and `inbatch_negatives` counts, and how different distributions might affect training. I'm also scrutinizing the `draw_full_history_filtered_negatives` function for a deeper understanding of in-batch negative sampling strategies."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Clarifying Target Definitions\n\nI'm re-examining the distinction between `unique_targets` and `targets_cpu` within the `draw_full_history_filtered_negatives` function. My current focus is on understanding the precise nature and dimensionality of `targets_cpu`, which appears to represent target items from a significant number of users and timesteps, to clarify its role in the sampling process."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Filtering Invalid Negatives\n\nI'm analyzing how invalid negatives are handled, particularly after identifying that `known_positive_packed` effectively masks all previously interacted items for a user. This seems to be the primary mechanism preventing sampling of already known positives, which is crucial."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Analyzing Correction Logic\n\nI am now focusing on the transformation of rejected in-batch items and the nuanced differences between uniform and in-batch negatives. I'm also investigating the role of `inbatch_correction_power` in weighting the loss based on item rarity, noting how it shifts focus towards rarer items."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Understanding In-Batch Negatives\n\nI'm exploring how in-batch negatives, items listened to by other users in the batch, provide more valuable training signals than purely random negatives. These provide niche signals specific to other users' tastes, helping the model learn finer distinctions crucial for music discovery."
},
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:16.167Z",
"text": "Exploring Negative Sampling Ratios\n\nI'm investigating how different ratios of in-batch versus uniform negatives might impact training. Specifically, I'm considering scenarios with equal numbers, more in-batch negatives, or entirely in-batch negatives, while ensuring the `corrected_negative_loss` mechanism remains intact."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:16.167Z",
"callId": "replace__call_4631404",
"name": "replace",
"input": {
"new_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total",
"allow_multiple": false,
"instruction": "Restore original corrected_negative_loss in train_current_model.py",
"file_path": "/app/solution/train_current_model.py",
"old_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)"
},
"recorded": {
"id": "replace__call_4631404",
"name": "replace",
"args": {
"new_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total",
"allow_multiple": false,
"instruction": "Restore original corrected_negative_loss in train_current_model.py",
"file_path": "/app/solution/train_current_model.py",
"old_string": "def corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)"
},
"result": [
{
"functionResponse": {
"id": "replace__call_4631404",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:30:16.181Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -850,7 +850,20 @@\n config: Config,\n ) -> torch.Tensor:\n raw = F.softplus(logits)\n- return raw.mean(dim=1)\n+ total = config.uniform_negatives + config.inbatch_negatives\n+ result = torch.zeros(len(logits), device=logits.device)\n+ if config.uniform_negatives:\n+ result += config.uniform_negatives * raw[\n+ :, : config.uniform_negatives\n+ ].mean(dim=1)\n+ if config.inbatch_negatives:\n+ selected = slice(config.uniform_negatives, total)\n+ weights = correction[:, selected]\n+ result += config.inbatch_negatives * (\n+ (raw[:, selected] * weights).sum(dim=1)\n+ / weights.sum(dim=1).clamp_min(1.0e-6)\n+ )\n+ return result / total\n \n \n def retained_target_window_starts(\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n return raw.mean(dim=1)\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 14,
"model_removed_lines": 1,
"model_added_chars": 576,
"model_removed_chars": 26,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: def corrected_negative_loss(... => def corrected_negative_loss(...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:30:16.184Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n...",
"isError": false
},
"responseMessageId": "1973d117-19eb-4675-882f-8f2e16a1bb19"
}
]
},
{
"id": 57,
"role": "agent",
"timestamp": "2026-09-29T06:30:22.494Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:22.494Z",
"text": "Exploring Configuration Options\n\nI'm currently investigating the feasibility of introducing CLI arguments for `--uniform-negatives`, `--inbatch-negatives`, and `--inbatch-correction-power`. My immediate focus is on integrating these into the `Config` structure."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:22.494Z",
"callId": "read_file__call_4046465",
"name": "read_file",
"input": {
"start_line": 1940,
"end_line": 2070,
"file_path": "/app/solution/train_current_model.py"
},
"recorded": {
"id": "read_file__call_4046465",
"name": "read_file",
"args": {
"start_line": 1940,
"end_line": 2070,
"file_path": "/app/solution/train_current_model.py"
},
"result": [
{
"functionResponse": {
"id": "read_file__call_4046465",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1940-2070 of 2186 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2071.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:30:22.499Z",
"resultDisplay": "Read lines 1940-2070 of 2186 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:30:22.501Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 1940-2070 of 2186 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2071.\n\n--- FILE CONTENT (truncated) ---\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)",
"isError": false
},
"responseMessageId": "2a4041d5-ef23-471f-ac43-74c5caca62eb"
}
]
},
{
"id": 58,
"role": "agent",
"timestamp": "2026-09-29T06:30:26.772Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:26.772Z",
"text": "Adding Training Parameters\n\nI'm integrating new parameters into the argument parser and configuration for `/app/solution/train_current_model.py`. This will allow for finer control over negative sampling and its correction during training."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:26.772Z",
"callId": "replace__call_5940073",
"name": "replace",
"input": {
"new_string": " parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )",
"file_path": "/app/solution/train_current_model.py",
"instruction": "Add negative sampling options to parser and config in main()",
"allow_multiple": false,
"old_string": " parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )"
},
"recorded": {
"id": "replace__call_5940073",
"name": "replace",
"args": {
"new_string": " parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )",
"file_path": "/app/solution/train_current_model.py",
"instruction": "Add negative sampling options to parser and config in main()",
"allow_multiple": false,
"old_string": " parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )"
},
"result": [
{
"functionResponse": {
"id": "replace__call_5940073",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:30:26.796Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -1955,6 +1955,31 @@\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n+ \"--uniform-negatives\",\n+ type=int,\n+ default=Config.uniform_negatives,\n+ )\n+ parser.add_argument(\n+ \"--inbatch-negatives\",\n+ type=int,\n+ default=Config.inbatch_negatives,\n+ )\n+ parser.add_argument(\n+ \"--inbatch-correction-power\",\n+ type=float,\n+ default=Config.inbatch_correction_power,\n+ )\n+ parser.add_argument(\n+ \"--inbatch-correction-min\",\n+ type=float,\n+ default=Config.inbatch_correction_min,\n+ )\n+ parser.add_argument(\n+ \"--inbatch-correction-max\",\n+ type=float,\n+ default=Config.inbatch_correction_max,\n+ )\n+ parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 25,
"model_removed_lines": 0,
"model_added_chars": 625,
"model_removed_chars": 0,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: parser.add_argument(... => parser.add_argument(...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:30:26.799Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n...",
"isError": false
},
"responseMessageId": "bcf7f18b-b48f-4784-9916-2caa6d0bce06"
}
]
},
{
"id": 59,
"role": "agent",
"timestamp": "2026-09-29T06:30:30.363Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:30.363Z",
"callId": "read_file__call_94431",
"name": "read_file",
"input": {
"file_path": "/app/solution/train_current_model.py",
"start_line": 2070,
"end_line": 2100
},
"recorded": {
"id": "read_file__call_94431",
"name": "read_file",
"args": {
"file_path": "/app/solution/train_current_model.py",
"start_line": 2070,
"end_line": 2100
},
"result": [
{
"functionResponse": {
"id": "read_file__call_94431",
"name": "read_file",
"response": {
"output": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2070-2100 of 2211 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2101.\n\n--- FILE CONTENT (truncated) ---\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:30:30.368Z",
"resultDisplay": "Read lines 2070-2100 of 2211 from solution/train_current_model.py",
"description": "solution/train_current_model.py",
"displayName": "ReadFile",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:30:30.369Z",
"content": "\nIMPORTANT: The file content has been truncated.\nStatus: Showing lines 2070-2100 of 2211 total lines.\nAction: To read more of the file, you can use the 'start_line' and 'end_line' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use start_line: 2101.\n\n--- FILE CONTENT (truncated) ---\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()",
"isError": false
},
"responseMessageId": "d553ba70-1d45-4c5d-952d-6a16687089ca"
}
]
},
{
"id": 60,
"role": "agent",
"timestamp": "2026-09-29T06:30:33.585Z",
"blocks": [
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:33.585Z",
"callId": "replace__call_42315",
"name": "replace",
"input": {
"instruction": "Pass uniform_negatives and inbatch parameters to Config in main()",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"old_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,",
"new_string": " negative_filter_scope=args.negative_filter_scope,\n uniform_negatives=args.uniform_negatives,\n inbatch_negatives=args.inbatch_negatives,\n inbatch_correction_power=args.inbatch_correction_power,\n inbatch_correction_min=args.inbatch_correction_min,\n inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,"
},
"recorded": {
"id": "replace__call_42315",
"name": "replace",
"args": {
"instruction": "Pass uniform_negatives and inbatch parameters to Config in main()",
"file_path": "/app/solution/train_current_model.py",
"allow_multiple": false,
"old_string": " negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,",
"new_string": " negative_filter_scope=args.negative_filter_scope,\n uniform_negatives=args.uniform_negatives,\n inbatch_negatives=args.inbatch_negatives,\n inbatch_correction_power=args.inbatch_correction_power,\n inbatch_correction_min=args.inbatch_correction_min,\n inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,"
},
"result": [
{
"functionResponse": {
"id": "replace__call_42315",
"name": "replace",
"response": {
"output": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n uniform_negatives=args.uniform_negatives,\n inbatch_negatives=args.inbatch_negatives,\n inbatch_correction_power=args.inbatch_correction_power,\n inbatch_correction_min=args.inbatch_correction_min,\n inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n..."
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:30:33.599Z",
"resultDisplay": {
"fileDiff": "Index: train_current_model.py\n===================================================================\n--- train_current_model.py\tCurrent\n+++ train_current_model.py\tProposed\n@@ -2076,6 +2076,11 @@\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n+ uniform_negatives=args.uniform_negatives,\n+ inbatch_negatives=args.inbatch_negatives,\n+ inbatch_correction_power=args.inbatch_correction_power,\n+ inbatch_correction_min=args.inbatch_correction_min,\n+ inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n",
"fileName": "train_current_model.py",
"filePath": "/app/solution/train_current_model.py",
"originalContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"newContent": "#!/usr/bin/env python3\n\"\"\"Train the Yambda windowed two-tower baseline.\n\nEvery catalog listen with at least 50 percent completion is a sequence token.\nWithin each selected chronological window, every adjacent target contributes a\nloss. The fast default retains each user's most recent 128 training targets and\n16 held-out validation targets; passing zero for either cap restores the\nuncapped behavior for that side of the split. A 100-step truncated-BPTT block\ncomputes all of its timestep losses and carries the detached GRU hidden state\ninto the next block.\n\nThe model is a pure two-tower retriever: no user-ID embedding, no output\nnormalization, raw dot-product retrieval, sample-weighted binary cross entropy,\nand 24 uniform plus eight propensity-corrected unique in-batch negatives. Every\nselected adjacent target retains a nonzero weight. Only files under the supplied\npublic directory are read.\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport json\nimport random\nimport sys\nimport time\nfrom dataclasses import asdict, dataclass\nfrom pathlib import Path\n\nimport numpy as np\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nimport two_tower_model as base\n\n\nCACHE_VERSION = 2\n\n\n@dataclass(frozen=True)\nclass Config:\n bptt_steps: int = 100\n user_batch_size: int = 64\n embedding_dim: int = 192\n hidden_dim: int = 192\n user_hidden_1: int = 512\n user_hidden_2: int = 256\n item_hidden_1: int = 512\n item_hidden_2: int = 256\n dropout: float = 0.05\n epochs: int = 1\n learning_rate: float = 1.0e-3\n weight_decay: float = 1.0e-5\n gradient_clip: float = 2.0\n loss_microbatch_size: int = 65_536\n uniform_negatives: int = 24\n inbatch_negatives: int = 8\n inbatch_correction_power: float = 0.5\n inbatch_correction_min: float = 0.25\n inbatch_correction_max: float = 4.0\n negative_filter_scope: str = \"full-training-history\"\n target_weighting: str = \"organic-strong\"\n loss_type: str = \"infonce\"\n temperature: float = 0.1\n ordinary_target_weight: float = 0.25\n organic_strong_target_weight: float = 1.0\n organic_like_target_weight: float = 3.0\n discovery_horizon_days: int = 7\n validation_fraction: float = 0.10\n max_train_targets_per_user: int = 128\n max_validation_targets_per_user: int = 16\n early_stopping_patience: int = 1\n early_stopping_min_delta: float = 1.0e-4\n seed: int = 29\n\n\n@dataclass(frozen=True)\nclass CandidateSet:\n uids: np.ndarray\n item_ids: np.ndarray\n packed: np.ndarray\n\n @classmethod\n def read(cls, path: Path) -> \"CandidateSet\":\n with np.load(path, allow_pickle=False) as artifact:\n result = cls(\n uids=artifact[\"uids\"].astype(np.int64, copy=True),\n item_ids=artifact[\"item_ids\"].astype(np.int64, copy=True),\n packed=artifact[\"packed_eligible\"].astype(np.uint8, copy=True),\n )\n expected = (len(result.uids), (len(result.item_ids) + 7) // 8)\n if result.packed.shape != expected:\n raise ValueError(\n f\"invalid candidate artifact shape {result.packed.shape}; \"\n f\"expected {expected}\"\n )\n return result\n\n\n@dataclass(frozen=True)\nclass SequenceData:\n item_ids: np.ndarray\n item_features: np.ndarray\n user_ids: np.ndarray\n offsets: np.ndarray\n sequence_timestamps: np.ndarray\n sequence_items: np.ndarray\n event_features: np.ndarray\n activity_features: np.ndarray\n state_ids: np.ndarray\n liked_states: np.ndarray\n disliked_states: np.ndarray\n state_counts: np.ndarray\n inference_user_rows: np.ndarray\n inference_liked_items: np.ndarray\n inference_disliked_items: np.ndarray\n inference_user_features: np.ndarray\n\n @property\n def lengths(self) -> np.ndarray:\n return np.diff(self.offsets)\n\n @property\n def target_count(self) -> int:\n return int(np.maximum(self.lengths - 1, 0).sum())\n\n\n@dataclass(frozen=True)\nclass TargetPartition:\n \"\"\"A contiguous recent target window and its chronological BCE split.\"\"\"\n\n window_starts: np.ndarray\n training_counts: np.ndarray\n validation_counts: np.ndarray\n history_training_counts: np.ndarray\n\n @property\n def selected_count(self) -> int:\n return int(self.training_counts.sum() + self.validation_counts.sum())\n\n\ndef log(message: str) -> None:\n print(message, file=sys.stderr, flush=True)\n\n\ndef seed_everything(seed: int) -> None:\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n\n\ndef model_config(config: Config) -> base.TowerConfig:\n \"\"\"Map the dense trainer configuration onto the unchanged tower.\"\"\"\n return base.TowerConfig(\n sequence_length=config.bptt_steps,\n embedding_dim=config.embedding_dim,\n hidden_dim=config.hidden_dim,\n user_hidden_1=config.user_hidden_1,\n user_hidden_2=config.user_hidden_2,\n item_hidden_1=config.item_hidden_1,\n item_hidden_2=config.item_hidden_2,\n dropout=config.dropout,\n epochs=config.epochs,\n learning_rate=config.learning_rate,\n weight_decay=config.weight_decay,\n gradient_clip=config.gradient_clip,\n uniform_negatives=config.uniform_negatives,\n inbatch_negatives=config.inbatch_negatives,\n inbatch_correction_power=config.inbatch_correction_power,\n inbatch_correction_min=config.inbatch_correction_min,\n inbatch_correction_max=config.inbatch_correction_max,\n seed=config.seed,\n )\n\n\ndef append_state_snapshot(\n active_likes: dict[int, int],\n active_dislikes: dict[int, int],\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> int:\n liked_states.append(base.pack_active_items(active_likes, base.LIKE_ITEMS, n_items))\n disliked_states.append(\n base.pack_active_items(active_dislikes, base.DISLIKE_ITEMS, n_items)\n )\n state_counts.append((len(active_likes), len(active_dislikes)))\n return len(liked_states) - 1\n\n\ndef causal_activity_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n organic: np.ndarray,\n completion: np.ndarray,\n) -> np.ndarray:\n \"\"\"Compute the first four reviewed user features at every event cutoff.\"\"\"\n length = len(items)\n result = np.zeros((length, 4), dtype=np.float16)\n if not length:\n return result\n left_rows = np.searchsorted(\n timestamps,\n timestamps - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n rows = np.arange(length, dtype=np.int64)\n counts = rows - left_rows + 1\n organic_sum = np.cumsum(organic.astype(np.float64))\n completion_sum = np.cumsum(np.minimum(completion, 100).astype(np.float64))\n before_organic = np.where(\n left_rows > 0, organic_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n before_completion = np.where(\n left_rows > 0, completion_sum[np.maximum(left_rows - 1, 0)], 0.0\n )\n\n unique_counts = np.empty(length, dtype=np.int32)\n frequencies: dict[int, int] = {}\n left = 0\n for right, raw_item in enumerate(items):\n item = int(raw_item)\n frequencies[item] = frequencies.get(item, 0) + 1\n required_left = int(left_rows[right])\n while left < required_left:\n old_item = int(items[left])\n remaining = frequencies[old_item] - 1\n if remaining:\n frequencies[old_item] = remaining\n else:\n del frequencies[old_item]\n left += 1\n unique_counts[right] = len(frequencies)\n\n result[:, 0] = (np.log1p(counts) / 8.0).astype(np.float16)\n result[:, 1] = (np.log1p(unique_counts) / 6.0).astype(np.float16)\n result[:, 2] = (\n (organic_sum - before_organic) / np.maximum(counts, 1)\n ).astype(np.float16)\n result[:, 3] = (\n (completion_sum - before_completion)\n / np.maximum(counts, 1)\n / 100.0\n ).astype(np.float16)\n return result\n\n\ndef build_sequence_parts(\n listens: base.ListenEvents,\n explicit: base.ExplicitEvents,\n n_items: int,\n liked_states: list[np.ndarray],\n disliked_states: list[np.ndarray],\n state_counts: list[tuple[int, int]],\n) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray] | None:\n qualifying = listens.completion_pct >= base.LISTEN_POSITIVE_THRESHOLD\n timestamps = listens.timestamps[qualifying].astype(np.int64, copy=False)\n items = listens.items[qualifying].astype(np.uint16, copy=False)\n organic = listens.organic[qualifying].astype(np.float32, copy=False)\n completion = listens.completion_pct[qualifying].astype(np.float32, copy=False)\n if not len(items):\n return None\n\n event_features = np.zeros((len(items), 3), dtype=np.float16)\n event_features[:, 0] = organic.astype(np.float16)\n event_features[:, 1] = (\n np.minimum(completion, 100.0) / 100.0\n ).astype(np.float16)\n if len(items) > 1:\n gaps = np.maximum(0, timestamps[1:] - timestamps[:-1])\n event_features[1:, 2] = np.exp(\n -gaps.astype(np.float64) / (60.0 * base.DAY)\n ).astype(np.float16)\n\n activity = causal_activity_features(\n timestamps, items, organic, completion\n )\n states = np.zeros(len(items), dtype=np.uint32)\n active_likes: dict[int, int] = {}\n active_dislikes: dict[int, int] = {}\n explicit_position = 0\n current_state = 0\n for row, timestamp in enumerate(timestamps):\n changed = False\n while (\n explicit_position < len(explicit.timestamps)\n and int(explicit.timestamps[explicit_position]) < int(timestamp)\n ):\n item = int(explicit.items[explicit_position])\n event_timestamp = int(explicit.timestamps[explicit_position])\n destination = (\n active_likes\n if int(explicit.channel[explicit_position]) == 0\n else active_dislikes\n )\n if int(explicit.active[explicit_position]) == 1:\n destination[item] = event_timestamp\n else:\n destination.pop(item, None)\n explicit_position += 1\n changed = True\n if changed:\n current_state = append_state_snapshot(\n active_likes,\n active_dislikes,\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n states[row] = np.uint32(current_state)\n return timestamps, items.copy(), event_features, activity, states\n\n\ndef final_user_features(\n timestamps: np.ndarray,\n items: np.ndarray,\n event_features: np.ndarray,\n history_end: int,\n like_count: int,\n dislike_count: int,\n) -> np.ndarray:\n start = int(\n np.searchsorted(\n timestamps,\n history_end - base.PROFILE_LOOKBACK_DAYS * base.DAY,\n side=\"left\",\n )\n )\n result = np.zeros(6, dtype=np.float32)\n recent_items = items[start:]\n if len(recent_items):\n result[0] = np.log1p(len(recent_items)) / 8.0\n result[1] = np.log1p(len(np.unique(recent_items))) / 6.0\n result[2] = float(np.mean(event_features[start:, 0]))\n result[3] = float(np.mean(event_features[start:, 1]))\n result[4] = np.log1p(like_count) / 6.0\n result[5] = np.log1p(dislike_count) / 4.0\n return result\n\n\ndef prepare_data(\n public: Path, stage: str, config: Config\n) -> tuple[SequenceData, CandidateSet]:\n data = public / \"data\"\n catalog = pd.read_parquet(data / \"candidate_catalog.parquet\").sort_values(\n \"popularity_rank\"\n )\n item_ids = catalog.item_id.to_numpy(dtype=np.int64, copy=True)\n item_index = pd.Index(item_ids)\n n_items = len(item_ids)\n if n_items >= np.iinfo(np.uint16).max:\n raise RuntimeError(\"uint16 item storage is too small for this catalog\")\n\n if stage == \"validation\":\n prefixes = (\"train\",)\n history_end = base.TRAIN_END\n candidate_name = \"validation_eligible_candidates.npz\"\n state_name = \"validation_preference_state.parquet\"\n else:\n prefixes = (\"train\", \"val\")\n history_end = base.VALIDATION_END\n candidate_name = \"test_eligible_candidates.npz\"\n state_name = \"test_preference_state.parquet\"\n eligibility = CandidateSet.read(data / candidate_name)\n if not np.array_equal(eligibility.item_ids, item_ids):\n raise RuntimeError(\"catalog and candidate artifact item order differ\")\n\n explicit_by_user = base.load_explicit_events(data, prefixes, item_index)\n inference_likes, inference_dislikes, like_counts, dislike_counts = (\n base.load_inference_state(\n data / state_name,\n item_index,\n eligibility.uids,\n n_items,\n )\n )\n inference_rows = {int(uid): row for row, uid in enumerate(eligibility.uids)}\n inference_user_features = np.zeros((len(eligibility.uids), 6), dtype=np.float32)\n inference_sequence_rows = np.full(len(eligibility.uids), -1, dtype=np.int32)\n\n # Snapshot zero is the shared empty explicit state.\n liked_states = [np.full(base.LIKE_ITEMS, n_items, dtype=np.uint16)]\n disliked_states = [\n np.full(base.DISLIKE_ITEMS, n_items, dtype=np.uint16)\n ]\n state_counts: list[tuple[int, int]] = [(0, 0)]\n user_ids: list[int] = []\n offsets = [0]\n timestamp_parts: list[np.ndarray] = []\n item_parts: list[np.ndarray] = []\n event_parts: list[np.ndarray] = []\n activity_parts: list[np.ndarray] = []\n state_parts: list[np.ndarray] = []\n\n listen_paths = [data / f\"{prefix}_listens.parquet\" for prefix in prefixes]\n started = time.monotonic()\n for seen_users, (uid, listens) in enumerate(\n base.merge_listen_streams(listen_paths, item_index), start=1\n ):\n parts = build_sequence_parts(\n listens,\n explicit_by_user.get(uid, base.empty_explicit_events()),\n n_items,\n liked_states,\n disliked_states,\n state_counts,\n )\n if parts is None:\n continue\n sequence_row = len(user_ids)\n user_ids.append(uid)\n timestamp_parts.append(parts[0].astype(np.uint32, copy=False))\n item_parts.append(parts[1])\n event_parts.append(parts[2])\n activity_parts.append(parts[3])\n state_parts.append(parts[4])\n offsets.append(offsets[-1] + len(parts[1]))\n inference_row = inference_rows.get(uid)\n if inference_row is not None:\n inference_sequence_rows[inference_row] = sequence_row\n inference_user_features[inference_row] = final_user_features(\n parts[0],\n parts[1],\n parts[2],\n history_end,\n int(like_counts[inference_row]),\n int(dislike_counts[inference_row]),\n )\n if seen_users % 1_000 == 0:\n log(\n f\"prepared users={seen_users:,} tokens={offsets[-1]:,} \"\n f\"states={len(liked_states):,} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n missing = np.flatnonzero(inference_sequence_rows < 0)\n if len(missing):\n inference_user_features[missing, 4] = np.log1p(like_counts[missing]) / 6.0\n inference_user_features[missing, 5] = (\n np.log1p(dislike_counts[missing]) / 4.0\n )\n log(f\"target users without qualifying catalog sequence={len(missing):,}\")\n\n prepared = SequenceData(\n item_ids=item_ids,\n item_features=base.build_item_features(catalog),\n user_ids=np.asarray(user_ids, dtype=np.int64),\n offsets=np.asarray(offsets, dtype=np.int64),\n sequence_timestamps=np.concatenate(timestamp_parts),\n sequence_items=np.concatenate(item_parts),\n event_features=np.concatenate(event_parts),\n activity_features=np.concatenate(activity_parts),\n state_ids=np.concatenate(state_parts),\n liked_states=np.stack(liked_states),\n disliked_states=np.stack(disliked_states),\n state_counts=np.asarray(state_counts, dtype=np.int32),\n inference_user_rows=inference_sequence_rows,\n inference_liked_items=inference_likes,\n inference_disliked_items=inference_dislikes,\n inference_user_features=inference_user_features,\n )\n log(\n f\"prepared stage={stage} sequence_users={len(prepared.user_ids):,} \"\n f\"tokens={len(prepared.sequence_items):,} \"\n f\"next_item_targets={prepared.target_count:,} \"\n f\"states={len(prepared.liked_states):,}\"\n )\n return prepared, eligibility\n\n\ndef cache_metadata(stage: str, config: Config) -> dict[str, object]:\n return {\n \"cache_version\": CACHE_VERSION,\n \"stage\": stage,\n \"positive_listen_threshold\": base.LISTEN_POSITIVE_THRESHOLD,\n \"profile_lookback_days\": base.PROFILE_LOOKBACK_DAYS,\n \"event_time_feature\": \"exp-negative-gap-over-60-days\",\n }\n\n\ndef save_cache(\n path: Path, prepared: SequenceData, stage: str, config: Config\n) -> None:\n path.parent.mkdir(parents=True, exist_ok=True)\n np.savez(\n path,\n metadata=np.asarray(json.dumps(cache_metadata(stage, config), sort_keys=True)),\n **prepared.__dict__,\n )\n log(f\"saved public-derived full-sequence cache: {path}\")\n\n\ndef load_cache(path: Path, stage: str, config: Config) -> SequenceData:\n with np.load(path, allow_pickle=False) as artifact:\n actual = json.loads(str(artifact[\"metadata\"].item()))\n expected = cache_metadata(stage, config)\n if actual != expected:\n raise RuntimeError(f\"sequence cache differs: {actual} != {expected}\")\n values = {\n field: artifact[field].copy()\n for field in SequenceData.__dataclass_fields__\n }\n prepared = SequenceData(**values)\n log(\n f\"loaded full-sequence cache: tokens={len(prepared.sequence_items):,} \"\n f\"targets={prepared.target_count:,}\"\n )\n return prepared\n\n\ndef load_or_prepare(\n public: Path,\n stage: str,\n config: Config,\n cache: Path | None,\n) -> tuple[SequenceData, CandidateSet]:\n candidate_name = (\n \"validation_eligible_candidates.npz\"\n if stage == \"validation\"\n else \"test_eligible_candidates.npz\"\n )\n eligibility = CandidateSet.read(public / \"data\" / candidate_name)\n if cache is not None and cache.is_file():\n prepared = load_cache(cache, stage, config)\n if not np.array_equal(prepared.item_ids, eligibility.item_ids):\n raise RuntimeError(\"cached catalog differs from candidate artifact\")\n return prepared, eligibility\n prepared, built_eligibility = prepare_data(public, stage, config)\n if cache is not None:\n save_cache(cache, prepared, stage, config)\n return prepared, built_eligibility\n\n\ndef build_item_correction(\n prepared: SequenceData,\n config: Config,\n target_starts: np.ndarray,\n target_counts: np.ndarray,\n) -> torch.Tensor:\n \"\"\"Estimate in-batch propensities from the selected training targets.\"\"\"\n counts = np.zeros(len(prepared.item_ids), dtype=np.float64)\n for user_row, count in enumerate(target_counts):\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n target_start = int(target_starts[user_row])\n counts += np.bincount(\n prepared.sequence_items[\n offset\n + target_start\n + 1 : offset\n + target_start\n + int(count)\n + 1\n ].astype(np.int64),\n minlength=len(prepared.item_ids),\n )\n total = float(counts.sum())\n probabilities = (counts + 1.0) / (total + len(counts))\n raw = np.power(\n (1.0 / len(counts)) / probabilities,\n config.inbatch_correction_power,\n )\n normalization = float(np.sum(counts * raw) / max(total, 1.0))\n correction = np.clip(\n raw / max(normalization, 1.0e-12),\n config.inbatch_correction_min,\n config.inbatch_correction_max,\n ).astype(np.float32)\n mean_on_targets = float(np.sum(counts * correction) / max(total, 1.0))\n log(\n f\"inbatch correction: min={correction.min():.3f} \"\n f\"mean_on_targets={mean_on_targets:.3f} max={correction.max():.3f}\"\n )\n return torch.from_numpy(correction)\n\n\ndef build_known_positive_filter(\n prepared: SequenceData, training_counts: np.ndarray\n) -> np.ndarray:\n \"\"\"Pack each user's complete public-training positive-item set.\"\"\"\n width = (len(prepared.item_ids) + 7) // 8\n packed = np.zeros((len(prepared.user_ids), width), dtype=np.uint8)\n retained = 0\n for user_row, target_count in enumerate(training_counts):\n if not target_count:\n continue\n offset = int(prepared.offsets[user_row])\n # T adjacent targets consume sequence positions 0 through T. The\n # chronological BCE suffix starts at T + 1 and is intentionally absent.\n items = np.unique(\n prepared.sequence_items[\n offset : offset + int(target_count) + 1\n ].astype(np.int64)\n )\n byte_columns = items >> 3\n bit_values = np.left_shift(\n np.uint8(1), (items & 7).astype(np.uint8)\n )\n np.bitwise_or.at(packed[user_row], byte_columns, bit_values)\n retained += len(items)\n log(\n f\"full-history false-negative filter: users={len(prepared.user_ids):,} \"\n f\"unique_user_items={retained:,} bytes={packed.nbytes:,}\"\n )\n return packed\n\n\ndef invalid_full_history_negatives(\n negatives: np.ndarray,\n targets: np.ndarray,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray,\n liked_items: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return row-level invalid negatives using the complete training prefix.\"\"\"\n byte_columns = negatives >> 3\n bit_columns = negatives & 7\n known = known_positive_packed[user_rows[:, None], byte_columns]\n invalid = ((known >> bit_columns) & 1).astype(bool)\n invalid |= negatives == targets[:, None]\n invalid |= (negatives[:, :, None] == liked_items[:, None, :]).any(axis=2)\n for column in range(1, negatives.shape[1]):\n invalid[:, column] |= (\n negatives[:, column, None] == negatives[:, :column]\n ).any(axis=1)\n return invalid\n\n\ndef draw_full_history_filtered_negatives(\n targets: torch.Tensor,\n user_rows: np.ndarray,\n liked_items: torch.Tensor,\n known_positive_packed: np.ndarray,\n n_items: int,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Draw mixed negatives and reject all known public-training positives.\"\"\"\n targets_cpu = targets.detach().cpu().numpy().astype(np.int64, copy=False)\n liked_cpu = liked_items.detach().cpu().numpy().astype(np.int64, copy=False)\n batch_size = len(targets_cpu)\n uniform = torch.randint(\n n_items,\n (batch_size, config.uniform_negatives),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.empty((batch_size, 0), dtype=torch.long)\n corrected_count = 0\n if config.inbatch_negatives:\n unique_targets = torch.unique(targets.detach().cpu())\n corrected_count = min(\n config.inbatch_negatives, max(len(unique_targets) - 1, 0)\n )\n if corrected_count:\n priorities = torch.rand(\n (batch_size, len(unique_targets)), generator=generator\n )\n priorities.masked_fill_(\n unique_targets[None, :].eq(\n torch.from_numpy(targets_cpu)[:, None]\n ),\n -1.0,\n )\n columns = torch.topk(\n priorities, k=corrected_count, dim=1\n ).indices\n inbatch = unique_targets[columns]\n if corrected_count < config.inbatch_negatives:\n filler = torch.randint(\n n_items,\n (batch_size, config.inbatch_negatives - corrected_count),\n generator=generator,\n device=\"cpu\",\n )\n inbatch = torch.cat([inbatch, filler], dim=1)\n\n negatives = torch.cat([uniform, inbatch], dim=1).numpy()\n correction = np.ones_like(negatives, dtype=np.float32)\n if corrected_count:\n correction[\n :, config.uniform_negatives : config.uniform_negatives + corrected_count\n ] = item_correction[inbatch[:, :corrected_count]].numpy()\n for _ in range(32):\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if not np.any(invalid):\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n replacements = torch.randint(\n n_items,\n (int(invalid.sum()),),\n generator=generator,\n device=\"cpu\",\n ).numpy()\n negatives[invalid] = replacements\n # Rejected in-batch items become ordinary uniform draws.\n correction[invalid] = 1.0\n invalid = invalid_full_history_negatives(\n negatives,\n targets_cpu,\n user_rows,\n known_positive_packed,\n liked_cpu,\n )\n if np.any(invalid):\n raise RuntimeError(\"full-history negative resampling failed\")\n return (\n torch.from_numpy(negatives).to(device),\n torch.from_numpy(correction).to(device),\n )\n\n\ndef draw_training_negatives(\n positive_items: torch.Tensor,\n known_history: torch.Tensor,\n liked_items: torch.Tensor,\n user_rows: np.ndarray,\n known_positive_packed: np.ndarray | None,\n prepared: SequenceData,\n config: Config,\n item_correction: torch.Tensor,\n generator: torch.Generator,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor]:\n if config.negative_filter_scope == \"full-training-history\":\n if known_positive_packed is None:\n raise RuntimeError(\"full-history negative filter was not built\")\n return draw_full_history_filtered_negatives(\n positive_items,\n user_rows,\n liked_items,\n known_positive_packed,\n len(prepared.item_ids),\n config,\n item_correction,\n generator,\n device,\n )\n return base.draw_filtered_mixed_negatives(\n positive_items,\n known_history,\n liked_items,\n len(prepared.item_ids),\n config.uniform_negatives,\n config.inbatch_negatives,\n item_correction,\n generator,\n device,\n )\n\n\ndef event_sequence(\n model: base.SequentialTwoTower,\n items: torch.Tensor,\n features: torch.Tensor,\n hidden: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n inputs = torch.cat([model.context_embedding(items), features], dim=-1)\n projected = model.event_projection(inputs)\n return model.sequence_encoder(projected, hidden)\n\n\ndef pool_explicit_states(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n state_ids: np.ndarray,\n device: torch.device,\n) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n unique_states, inverse = np.unique(state_ids, return_inverse=True)\n liked_items = torch.from_numpy(\n prepared.liked_states[unique_states].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.disliked_states[unique_states].astype(np.int64)\n ).to(device)\n liked_vectors = model._mean_context_channel(liked_items)\n disliked_vectors = model._mean_context_channel(disliked_items)\n inverse_rows = torch.from_numpy(inverse.astype(np.int64)).to(device)\n counts = prepared.state_counts[state_ids]\n return (\n liked_vectors[inverse_rows],\n disliked_vectors[inverse_rows],\n torch.from_numpy(counts.astype(np.float32)).to(device),\n )\n\n\ndef user_queries(\n model: base.SequentialTwoTower,\n sequence_vectors: torch.Tensor,\n liked_vectors: torch.Tensor,\n disliked_vectors: torch.Tensor,\n user_features: torch.Tensor,\n) -> torch.Tensor:\n return model.user_tower(\n torch.cat(\n [sequence_vectors, liked_vectors, disliked_vectors, user_features],\n dim=1,\n )\n )\n\n\ndef candidate_vectors(\n model: base.SequentialTwoTower,\n positives: torch.Tensor,\n negatives: torch.Tensor,\n) -> tuple[torch.Tensor, torch.Tensor]:\n all_items = torch.cat([positives, negatives.reshape(-1)])\n unique_items, inverse = torch.unique(all_items, return_inverse=True)\n encoded = model.encode_items(unique_items)\n positive_vectors = encoded[inverse[: len(positives)]]\n negative_vectors = encoded[inverse[len(positives) :]].reshape(\n len(positives), negatives.shape[1], -1\n )\n return positive_vectors, negative_vectors\n\n\ndef history_windows(\n sequence: np.ndarray,\n start: int,\n count: int,\n width: int,\n padding_item: int,\n) -> np.ndarray:\n base_start = max(0, start - width + 1)\n segment = sequence[base_start : start + count]\n padded = np.concatenate(\n [np.full(width - 1, padding_item, dtype=np.uint16), segment]\n )\n windows = np.lib.stride_tricks.sliding_window_view(padded, width)\n offset = start - base_start\n return windows[offset : offset + count].copy()\n\n\ndef corrected_negative_loss(\n logits: torch.Tensor,\n correction: torch.Tensor,\n config: Config,\n) -> torch.Tensor:\n raw = F.softplus(logits)\n total = config.uniform_negatives + config.inbatch_negatives\n result = torch.zeros(len(logits), device=logits.device)\n if config.uniform_negatives:\n result += config.uniform_negatives * raw[\n :, : config.uniform_negatives\n ].mean(dim=1)\n if config.inbatch_negatives:\n selected = slice(config.uniform_negatives, total)\n weights = correction[:, selected]\n result += config.inbatch_negatives * (\n (raw[:, selected] * weights).sum(dim=1)\n / weights.sum(dim=1).clamp_min(1.0e-6)\n )\n return result / total\n\n\ndef retained_target_window_starts(\n total_targets: np.ndarray,\n validation_counts: np.ndarray,\n training_counts: np.ndarray,\n) -> np.ndarray:\n \"\"\"Return the discarded prefix before the retained chronological suffix.\"\"\"\n training_region_ends = total_targets - validation_counts\n window_starts = training_region_ends - training_counts\n if (\n np.any(window_starts < 0)\n or np.any(training_counts < 0)\n or np.any(validation_counts < 0)\n ):\n raise RuntimeError(\"chronological target partition produced negative counts\")\n if not np.array_equal(\n window_starts + training_counts + validation_counts, total_targets\n ):\n raise RuntimeError(\"chronological target window is not a final contiguous suffix\")\n return window_starts\n\n\ndef chronological_target_partition(\n prepared: SequenceData,\n validation_fraction: float,\n max_train_targets_per_user: int,\n max_validation_targets_per_user: int,\n) -> TargetPartition:\n \"\"\"Select a recent contiguous window with a final out-of-time BCE suffix.\"\"\"\n totals = np.maximum(prepared.lengths - 1, 0).astype(np.int64)\n validation = np.floor(totals * validation_fraction).astype(np.int64)\n validation[(totals >= 2) & (validation == 0)] = 1\n if max_validation_targets_per_user:\n validation = np.minimum(validation, max_validation_targets_per_user)\n\n history_training = totals - validation\n training = history_training.copy()\n if max_train_targets_per_user:\n training = np.minimum(training, max_train_targets_per_user)\n window_starts = retained_target_window_starts(totals, validation, training)\n return TargetPartition(\n window_starts=window_starts,\n training_counts=training,\n validation_counts=validation,\n history_training_counts=history_training,\n )\n\n\ndef load_organic_like_outcomes(\n public: Path, stage: str, item_ids: np.ndarray\n) -> dict[int, dict[int, np.ndarray]]:\n \"\"\"Load mapped organic-like timestamps from public fitting history.\"\"\"\n prefixes = (\"train\",) if stage == \"validation\" else (\"train\", \"val\")\n frames = [\n pd.read_parquet(\n public / \"data\" / f\"{prefix}_likes.parquet\",\n columns=[\"uid\", \"timestamp\", \"item_id\", \"is_organic\"],\n )\n for prefix in prefixes\n ]\n likes = pd.concat(frames, ignore_index=True)\n likes = likes[likes.is_organic == 1].copy()\n mapped = pd.Index(item_ids).get_indexer(\n likes.item_id.to_numpy(dtype=np.int64)\n )\n likes = likes.loc[mapped >= 0, [\"uid\", \"timestamp\"]].copy()\n likes[\"item\"] = mapped[mapped >= 0].astype(np.int32, copy=False)\n likes = likes.sort_values([\"uid\", \"item\", \"timestamp\"], kind=\"stable\")\n nested: dict[int, dict[int, list[int]]] = {}\n for raw_uid, raw_timestamp, raw_item in likes.itertuples(\n index=False, name=None\n ):\n nested.setdefault(int(raw_uid), {}).setdefault(int(raw_item), []).append(\n int(raw_timestamp)\n )\n result = {\n uid: {\n item: np.asarray(timestamps, dtype=np.int64)\n for item, timestamps in items.items()\n }\n for uid, items in nested.items()\n }\n log(\n f\"loaded organic-like outcomes: rows={len(likes):,} \"\n f\"users={len(result):,}\"\n )\n return result\n\n\ndef build_target_weights(\n public: Path,\n stage: str,\n prepared: SequenceData,\n training_counts: np.ndarray,\n config: Config,\n) -> np.ndarray:\n \"\"\"Build nonzero per-token weights without dropping adjacent targets.\"\"\"\n if config.target_weighting == \"uniform\":\n weights = np.ones(len(prepared.sequence_items), dtype=np.float32)\n else:\n weights = np.full(\n len(prepared.sequence_items),\n config.ordinary_target_weight,\n dtype=np.float32,\n )\n organic_strong = (\n (prepared.event_features[:, 0] > 0.5)\n & (prepared.event_features[:, 1] >= 0.8)\n )\n weights[organic_strong] = config.organic_strong_target_weight\n if config.target_weighting == \"discovery-graded\":\n like_outcomes = load_organic_like_outcomes(\n public, stage, prepared.item_ids\n )\n history_end = (\n base.TRAIN_END if stage == \"validation\" else base.VALIDATION_END\n )\n horizon = config.discovery_horizon_days * base.DAY\n grade_three = 0\n for user_row, uid in enumerate(prepared.user_ids):\n start = int(prepared.offsets[user_row])\n end = int(prepared.offsets[user_row + 1])\n if end - start < 2:\n continue\n last_training_target = start + int(training_counts[user_row])\n first_validation_target = last_training_target + 1\n split_timestamp = (\n int(prepared.sequence_timestamps[first_validation_target])\n if first_validation_target < end\n else history_end\n )\n user_likes = like_outcomes.get(int(uid), {})\n seen = {int(prepared.sequence_items[start])}\n for position in range(start + 1, end):\n item = int(prepared.sequence_items[position])\n novel = item not in seen\n seen.add(item)\n if not novel:\n # Repeats remain training examples, but they cannot be\n # eligible discovery outcomes at the corresponding\n # cutoff and therefore keep only the ordinary weight.\n weights[position] = config.ordinary_target_weight\n continue\n timestamps = user_likes.get(item)\n if timestamps is None:\n continue\n timestamp = int(prepared.sequence_timestamps[position])\n upper = min(\n timestamp + horizon,\n split_timestamp\n if position <= last_training_target\n else history_end,\n )\n outcome = int(np.searchsorted(timestamps, timestamp, side=\"left\"))\n if outcome < len(timestamps) and int(timestamps[outcome]) < upper:\n weights[position] = config.organic_like_target_weight\n grade_three += 1\n log(\n f\"grade-3 first-encounter targets={grade_three:,} \"\n f\"horizon_days={config.discovery_horizon_days}\"\n )\n log(\n f\"target weighting={config.target_weighting} \"\n f\"min={weights.min():.3f} mean={weights.mean():.3f} \"\n f\"max={weights.max():.3f}\"\n )\n return weights\n\n\ndef build_dense_block(\n prepared: SequenceData,\n target_weights: np.ndarray,\n users: np.ndarray,\n window_starts: np.ndarray,\n process_counts: np.ndarray,\n score_starts: np.ndarray,\n start: int,\n steps: int,\n config: Config,\n) -> tuple[np.ndarray, ...]:\n \"\"\"Build one causal sequence block and mark the target rows to score.\"\"\"\n batch_size = len(users)\n padding_item = len(prepared.item_ids)\n input_items = np.full((batch_size, steps), padding_item, dtype=np.uint16)\n event_features = np.zeros((batch_size, steps, 3), dtype=np.float16)\n activity_features = np.zeros((batch_size, steps, 4), dtype=np.float16)\n state_ids = np.zeros((batch_size, steps), dtype=np.uint32)\n targets = np.zeros((batch_size, steps), dtype=np.uint16)\n weights = np.ones((batch_size, steps), dtype=np.float32)\n scored = np.zeros((batch_size, steps), dtype=bool)\n histories = np.full(\n (batch_size, steps, config.bptt_steps),\n padding_item,\n dtype=np.uint16,\n )\n processed = np.zeros(batch_size, dtype=np.int32)\n\n lengths = prepared.lengths\n for row, user_row in enumerate(users):\n count = min(steps, max(int(process_counts[row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[user_row])\n window_start = int(window_starts[row])\n absolute_start = window_start + start\n positions = slice(\n offset + absolute_start,\n offset + absolute_start + count,\n )\n target_positions = slice(\n offset + absolute_start + 1,\n offset + absolute_start + count + 1,\n )\n input_items[row, :count] = prepared.sequence_items[positions]\n event_features[row, :count] = prepared.event_features[positions]\n activity_features[row, :count] = prepared.activity_features[positions]\n state_ids[row, :count] = prepared.state_ids[positions]\n targets[row, :count] = prepared.sequence_items[target_positions]\n weights[row, :count] = target_weights[target_positions]\n score_from = min(count, max(int(score_starts[row]) - start, 0))\n scored[row, score_from:count] = True\n processed[row] = count\n user_sequence = prepared.sequence_items[\n offset : offset + int(lengths[user_row])\n ]\n histories[row, :count] = history_windows(\n user_sequence,\n absolute_start,\n count,\n config.bptt_steps,\n padding_item,\n )\n return (\n input_items,\n event_features,\n activity_features,\n state_ids,\n targets,\n scored,\n histories,\n processed,\n weights,\n )\n\n\ndef score_target_microbatches(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n sequence_vectors: torch.Tensor,\n flat_states: np.ndarray,\n flat_activity: np.ndarray,\n positive_items: torch.Tensor,\n negatives: torch.Tensor,\n negative_weights: torch.Tensor,\n sample_weights: np.ndarray,\n device: torch.device,\n backward: bool,\n) -> tuple[dict[str, float], torch.Tensor | None]:\n \"\"\"Compute one logical block's exact BCE in bounded-memory slices.\"\"\"\n target_count = len(positive_items)\n total_weight = float(sample_weights.sum())\n if total_weight <= 0:\n raise RuntimeError(\"target block has no positive sample weight\")\n sequence_gradient = torch.zeros_like(sequence_vectors) if backward else None\n statistics = {\n \"loss_sum\": 0.0,\n \"positive_sum\": 0.0,\n \"negative_sum\": 0.0,\n \"pair_correct\": 0.0,\n \"weight_sum\": 0.0,\n }\n for begin in range(0, target_count, config.loss_microbatch_size):\n end = min(begin + config.loss_microbatch_size, target_count)\n selected_states = flat_states[begin:end]\n if backward:\n sequence_input = (\n sequence_vectors[begin:end].detach().requires_grad_(True)\n )\n else:\n sequence_input = sequence_vectors[begin:end]\n liked_vectors, disliked_vectors, _ = pool_explicit_states(\n model, prepared, selected_states, device\n )\n counts = prepared.state_counts[selected_states]\n numeric = np.zeros((end - begin, 6), dtype=np.float32)\n numeric[:, :4] = flat_activity[begin:end]\n numeric[:, 4] = np.log1p(counts[:, 0]) / 6.0\n numeric[:, 5] = np.log1p(counts[:, 1]) / 4.0\n query_vectors = user_queries(\n model,\n sequence_input,\n liked_vectors,\n disliked_vectors,\n torch.from_numpy(numeric).to(device),\n )\n positive_vectors, negative_vectors = candidate_vectors(\n model,\n positive_items[begin:end],\n negatives[begin:end],\n )\n positive_logits = (query_vectors * positive_vectors).sum(dim=1)\n negative_logits = torch.einsum(\n \"bd,bkd->bk\", query_vectors, negative_vectors\n )\n selected_weights = torch.from_numpy(\n sample_weights[begin:end].astype(np.float32, copy=False)\n ).to(device)\n if config.loss_type == \"infonce\":\n all_logits = torch.cat([positive_logits.unsqueeze(1), negative_logits], dim=1)\n scaled_logits = all_logits / config.temperature\n targets_idx = torch.zeros(len(positive_logits), dtype=torch.long, device=device)\n sample_loss = F.cross_entropy(scaled_logits, targets_idx, reduction=\"none\")\n loss_sum = (selected_weights * sample_loss).sum()\n else:\n positive_loss = F.softplus(-positive_logits)\n negative_loss = corrected_negative_loss(\n negative_logits, negative_weights[begin:end], config\n )\n loss_sum = (\n selected_weights * (positive_loss + negative_loss) / 2.0\n ).sum()\n if not bool(torch.isfinite(loss_sum)):\n raise RuntimeError(\"dense next-item training produced non-finite loss\")\n if backward:\n (loss_sum / total_weight).backward()\n if sequence_input.grad is None:\n raise RuntimeError(\"sequence microbatch did not produce a gradient\")\n sequence_gradient[begin:end] = sequence_input.grad\n statistics[\"loss_sum\"] += float(loss_sum.detach().cpu())\n statistics[\"positive_sum\"] += float(positive_logits.detach().sum().cpu())\n statistics[\"negative_sum\"] += float(negative_logits.detach().sum().cpu())\n statistics[\"pair_correct\"] += float(\n (positive_logits.detach()[:, None] > negative_logits.detach()).sum().cpu()\n )\n statistics[\"weight_sum\"] += float(selected_weights.sum().detach().cpu())\n return statistics, sequence_gradient\n\n\ndef release_accelerator_cache(device: torch.device) -> None:\n if device.type == \"mps\":\n torch.mps.empty_cache()\n\n\ndef run_training_epoch(\n model: base.SequentialTwoTower,\n optimizer: torch.optim.Optimizer,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n target_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n generator: torch.Generator,\n device: torch.device,\n epoch: int,\n) -> dict[str, float]:\n model.train()\n train_users = np.flatnonzero(target_counts > 0)\n sorted_users = train_users[\n np.argsort(target_counts[train_users], kind=\"stable\")\n ]\n groups = [\n sorted_users[start : start + config.user_batch_size]\n for start in range(0, len(sorted_users), config.user_batch_size)\n ]\n group_order = torch.randperm(len(groups), generator=generator).numpy()\n negative_count = config.uniform_negatives + config.inbatch_negatives\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n total_positive = 0.0\n total_negative = 0.0\n total_pair_correct = 0.0\n batches = 0\n started = time.monotonic()\n\n for group_number in group_order:\n users = groups[int(group_number)]\n group_counts = target_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_counts.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_counts,\n np.zeros(len(users), dtype=np.int64),\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0).detach()\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n optimizer.zero_grad(set_to_none=True)\n statistics, sequence_gradient = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=True,\n )\n if sequence_gradient is None:\n raise RuntimeError(\"training block omitted its sequence gradient\")\n sequence_vectors.backward(sequence_gradient)\n nn.utils.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n\n count = len(positive_items)\n total_loss += statistics[\"loss_sum\"]\n total_targets += count\n total_weight += statistics[\"weight_sum\"]\n total_positive += statistics[\"positive_sum\"]\n total_negative += statistics[\"negative_sum\"]\n total_pair_correct += statistics[\"pair_correct\"]\n batches += 1\n if batches % 25 == 0:\n release_accelerator_cache(device)\n if batches % 250 == 0:\n batch_bce = statistics[\"loss_sum\"] / max(\n statistics[\"weight_sum\"], 1.0e-12\n )\n running_bce = total_loss / max(total_weight, 1.0e-12)\n log(\n f\"epoch={epoch}/{config.epochs} batches={batches:,} \"\n f\"targets={total_targets:,} \"\n f\"batch_bce={batch_bce:.6f} \"\n f\"running_bce={running_bce:.6f} \"\n f\"elapsed={time.monotonic() - started:.1f}s\"\n )\n\n return {\n \"epoch\": float(epoch),\n \"loss\": total_loss / max(total_weight, 1.0e-12),\n \"positive_logit\": total_positive / max(total_targets, 1),\n \"negative_logit\": total_negative / max(total_targets * negative_count, 1),\n \"pair_accuracy\": total_pair_correct\n / max(total_targets * negative_count, 1),\n \"targets\": float(total_targets),\n \"target_weight_sum\": total_weight,\n \"batches\": float(batches),\n \"seconds\": time.monotonic() - started,\n }\n\n\n@torch.no_grad()\ndef evaluate_validation_bce(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n target_weights: np.ndarray,\n window_starts: np.ndarray,\n training_counts: np.ndarray,\n validation_counts: np.ndarray,\n item_correction: torch.Tensor,\n known_positive_packed: np.ndarray | None,\n device: torch.device,\n) -> dict[str, float]:\n \"\"\"Measure deterministic BCE on each user's chronological target suffix.\"\"\"\n model.eval()\n totals = training_counts + validation_counts\n users_with_validation = np.flatnonzero(validation_counts > 0)\n ordered = users_with_validation[\n np.argsort(totals[users_with_validation], kind=\"stable\")\n ]\n groups = [\n ordered[start : start + config.user_batch_size]\n for start in range(0, len(ordered), config.user_batch_size)\n ]\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 20_000)\n total_loss = 0.0\n total_targets = 0\n total_weight = 0.0\n started = time.monotonic()\n\n for group_number, users in enumerate(groups, start=1):\n group_totals = totals[users]\n group_starts = training_counts[users]\n hidden = torch.zeros(\n 1, len(users), config.embedding_dim, device=device\n )\n max_targets = int(group_totals.max())\n for start in range(0, max_targets, config.bptt_steps):\n steps = min(config.bptt_steps, max_targets - start)\n block = build_dense_block(\n prepared,\n target_weights,\n users,\n window_starts[users],\n group_totals,\n group_starts,\n start,\n steps,\n config,\n )\n sequence_outputs, _ = event_sequence(\n model,\n torch.from_numpy(block[0].astype(np.int64)).to(device),\n torch.from_numpy(block[1].astype(np.float32)).to(device),\n hidden,\n )\n hidden = torch.stack(\n [\n sequence_outputs[row, count - 1]\n if count\n else hidden[0, row]\n for row, count in enumerate(block[7])\n ]\n ).unsqueeze(0)\n flat_scored = block[5].reshape(-1)\n if not np.any(flat_scored):\n continue\n mask = torch.from_numpy(flat_scored).to(device)\n sequence_vectors = sequence_outputs.reshape(\n -1, config.embedding_dim\n )[mask]\n flat_states = block[3].reshape(-1)[flat_scored]\n positive_items = torch.from_numpy(\n block[4].reshape(-1)[flat_scored].astype(np.int64)\n ).to(device)\n known_history = torch.from_numpy(\n block[6].reshape(-1, config.bptt_steps)[flat_scored].astype(\n np.int64\n )\n ).to(device)\n liked_items = torch.from_numpy(\n prepared.liked_states[flat_states].astype(np.int64)\n ).to(device)\n flat_user_rows = np.broadcast_to(\n users[:, None], block[5].shape\n ).reshape(-1)[flat_scored]\n negatives, negative_weights = draw_training_negatives(\n positive_items,\n known_history,\n liked_items,\n flat_user_rows,\n known_positive_packed,\n prepared,\n config,\n item_correction,\n generator,\n device,\n )\n statistics, _ = score_target_microbatches(\n model,\n prepared,\n config,\n sequence_vectors,\n flat_states,\n block[2].reshape(-1, 4)[flat_scored].astype(np.float32),\n positive_items,\n negatives,\n negative_weights,\n block[8].reshape(-1)[flat_scored],\n device,\n backward=False,\n )\n total_loss += statistics[\"loss_sum\"]\n total_targets += len(positive_items)\n total_weight += statistics[\"weight_sum\"]\n if group_number % 25 == 0:\n release_accelerator_cache(device)\n return {\n \"validation_loss\": total_loss / max(total_weight, 1.0e-12),\n \"validation_targets\": float(total_targets),\n \"validation_target_weight_sum\": total_weight,\n \"validation_seconds\": time.monotonic() - started,\n }\n\n\ndef snapshot_model(model: nn.Module) -> dict[str, torch.Tensor]:\n return {\n name: value.detach().cpu().clone()\n for name, value in model.state_dict().items()\n }\n\n\ndef save_epoch_checkpoint(\n checkpoint_dir: Path,\n epoch: int,\n model_state: dict[str, torch.Tensor],\n config: Config,\n diagnostics: dict[str, float],\n optimizer: torch.optim.Optimizer,\n generator: torch.Generator,\n) -> Path:\n checkpoint_dir.mkdir(parents=True, exist_ok=True)\n path = checkpoint_dir / f\"epoch-{epoch:02d}.pt\"\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": model_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n path,\n )\n log(f\"saved epoch checkpoint: {path}\")\n return path\n\n\ndef train_model(\n public: Path,\n stage: str,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n checkpoint_dir: Path | None,\n resume_checkpoint: Path | None,\n) -> tuple[base.SequentialTwoTower, list[dict[str, float]]]:\n partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n training_counts = partition.training_counts\n validation_counts = partition.validation_counts\n log(\n f\"chronological BCE window: train={int(training_counts.sum()):,} \"\n f\"validation={int(validation_counts.sum()):,} \"\n f\"selected={partition.selected_count:,} \"\n f\"discarded_old_targets={int(partition.window_starts.sum()):,} \"\n f\"all={prepared.target_count:,}\"\n )\n model = base.SequentialTwoTower(prepared.item_features, model_config(config)).to(\n device\n )\n optimizer = torch.optim.AdamW(\n model.parameters(), lr=config.learning_rate, weight_decay=config.weight_decay\n )\n generator = torch.Generator(device=\"cpu\").manual_seed(config.seed + 10_000)\n item_correction = build_item_correction(\n prepared,\n config,\n partition.window_starts,\n training_counts,\n )\n target_weights = build_target_weights(\n public,\n stage,\n prepared,\n partition.history_training_counts,\n config,\n )\n known_positive_packed = (\n build_known_positive_filter(prepared, partition.history_training_counts)\n if config.negative_filter_scope == \"full-training-history\"\n else None\n )\n history: list[dict[str, float]] = []\n best_loss = float(\"inf\")\n best_epoch = 0\n best_state: dict[str, torch.Tensor] | None = None\n epochs_without_improvement = 0\n start_epoch = 0\n\n if resume_checkpoint is not None:\n payload = torch.load(\n resume_checkpoint, map_location=device, weights_only=False\n )\n stored_config = payload.get(\"config\", {})\n architecture_fields = (\n \"bptt_steps\",\n \"embedding_dim\",\n \"hidden_dim\",\n \"user_hidden_1\",\n \"user_hidden_2\",\n \"item_hidden_1\",\n \"item_hidden_2\",\n )\n mismatches = {\n name: (stored_config.get(name), getattr(config, name))\n for name in architecture_fields\n if stored_config.get(name) != getattr(config, name)\n }\n if mismatches:\n raise RuntimeError(\n f\"resume checkpoint architecture differs: {mismatches}\"\n )\n stored_filter_scope = stored_config.get(\n \"negative_filter_scope\", \"last-100\"\n )\n stored_target_weighting = stored_config.get(\n \"target_weighting\", \"uniform\"\n )\n stored_weight_values = (\n stored_config.get(\"ordinary_target_weight\", 1.0),\n stored_config.get(\"organic_strong_target_weight\", 1.0),\n stored_config.get(\"organic_like_target_weight\", 3.0),\n stored_config.get(\"discovery_horizon_days\", 7),\n )\n current_weight_values = (\n config.ordinary_target_weight,\n config.organic_strong_target_weight,\n config.organic_like_target_weight,\n config.discovery_horizon_days,\n )\n stored_window_values = (\n stored_config.get(\"validation_fraction\", 0.10),\n stored_config.get(\"max_train_targets_per_user\", 0),\n stored_config.get(\"max_validation_targets_per_user\", 0),\n )\n current_window_values = (\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n objective_changed = (\n stored_filter_scope != config.negative_filter_scope\n or stored_target_weighting != config.target_weighting\n or stored_weight_values != current_weight_values\n or stored_window_values != current_window_values\n )\n model.load_state_dict(payload[\"model_state\"])\n if \"optimizer_state\" in payload and not objective_changed:\n optimizer.load_state_dict(payload[\"optimizer_state\"])\n for group in optimizer.param_groups:\n group[\"lr\"] = config.learning_rate\n group[\"weight_decay\"] = config.weight_decay\n log(f\"restored optimizer state from {resume_checkpoint}\")\n else:\n log(\n f\"using a fresh AdamW optimizer after loading {resume_checkpoint}\"\n )\n if \"generator_state\" in payload and not objective_changed:\n generator.set_state(payload[\"generator_state\"])\n start_epoch = int(payload[\"epoch\"])\n if start_epoch >= config.epochs:\n raise RuntimeError(\n f\"resume epoch {start_epoch} must be below --epochs {config.epochs}\"\n )\n prior = {\n str(name): float(value)\n for name, value in payload.get(\"diagnostics\", {}).items()\n }\n if objective_changed:\n prior.pop(\"validation_loss\", None)\n log(\n \"BCE objective changed: filter \"\n f\"{stored_filter_scope}->{config.negative_filter_scope}, \"\n \"target weighting \"\n f\"{stored_target_weighting}->{config.target_weighting}, \"\n f\"target window {stored_window_values}->{current_window_values}; \"\n \"recomputing the resume checkpoint's validation BCE\"\n )\n if \"validation_loss\" not in prior:\n prior.update(\n evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n )\n history.append(prior)\n best_loss = float(prior[\"validation_loss\"])\n best_epoch = start_epoch\n best_state = snapshot_model(model)\n log(\n f\"resumed validation-BCE training: epoch={start_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n\n for epoch in range(start_epoch + 1, config.epochs + 1):\n diagnostics = run_training_epoch(\n model,\n optimizer,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n item_correction,\n known_positive_packed,\n generator,\n device,\n epoch,\n )\n validation = evaluate_validation_bce(\n model,\n prepared,\n config,\n target_weights,\n partition.window_starts,\n training_counts,\n validation_counts,\n item_correction,\n known_positive_packed,\n device,\n )\n diagnostics.update(validation)\n history.append(diagnostics)\n current_state = snapshot_model(model)\n if checkpoint_dir is not None:\n save_epoch_checkpoint(\n checkpoint_dir,\n epoch,\n current_state,\n config,\n diagnostics,\n optimizer,\n generator,\n )\n improved = (\n diagnostics[\"validation_loss\"]\n < best_loss - config.early_stopping_min_delta\n )\n if improved:\n best_loss = diagnostics[\"validation_loss\"]\n best_epoch = epoch\n best_state = current_state\n epochs_without_improvement = 0\n if checkpoint_dir is not None:\n torch.save(\n {\n \"epoch\": epoch,\n \"config\": asdict(config),\n \"diagnostics\": diagnostics,\n \"model_state\": current_state,\n \"optimizer_state\": optimizer.state_dict(),\n \"generator_state\": generator.get_state(),\n },\n checkpoint_dir / \"best.pt\",\n )\n else:\n epochs_without_improvement += 1\n log(\n f\"epoch={epoch}/{config.epochs} train_loss={diagnostics['loss']:.5f} \"\n f\"validation_loss={diagnostics['validation_loss']:.5f} \"\n f\"pair_accuracy={diagnostics['pair_accuracy']:.3f} \"\n f\"train_targets={int(diagnostics['targets']):,} \"\n f\"validation_targets={int(diagnostics['validation_targets']):,} \"\n f\"train_seconds={diagnostics['seconds']:.1f} \"\n f\"validation_seconds={diagnostics['validation_seconds']:.1f}\"\n )\n release_accelerator_cache(device)\n if epochs_without_improvement >= config.early_stopping_patience:\n log(\n f\"early stopping after epoch={epoch}; \"\n f\"best_epoch={best_epoch} best_validation_loss={best_loss:.6f}\"\n )\n break\n\n if best_state is None:\n raise RuntimeError(\"training did not produce a valid checkpoint\")\n model.load_state_dict(best_state)\n model.to(device).eval()\n log(\n f\"restored best validation-BCE checkpoint: epoch={best_epoch} \"\n f\"loss={best_loss:.6f}\"\n )\n return model, history\n\n\n@torch.inference_mode()\ndef inference_queries(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n config: Config,\n device: torch.device,\n) -> torch.Tensor:\n sequence_rows = prepared.inference_user_rows\n lengths = np.where(\n sequence_rows >= 0, prepared.lengths[np.maximum(sequence_rows, 0)], 0\n )\n ordered = np.argsort(lengths, kind=\"stable\")\n result = torch.zeros(\n len(sequence_rows), config.embedding_dim, dtype=torch.float32\n )\n for group_start in range(0, len(ordered), config.user_batch_size):\n output_rows = ordered[group_start : group_start + config.user_batch_size]\n rows = sequence_rows[output_rows]\n group_lengths = lengths[output_rows]\n hidden = torch.zeros(\n 1, len(output_rows), config.embedding_dim, device=device\n )\n for start in range(0, int(group_lengths.max(initial=0)), config.bptt_steps):\n steps = min(\n config.bptt_steps,\n int(group_lengths.max(initial=0)) - start,\n )\n items = np.full(\n (len(output_rows), steps),\n len(prepared.item_ids),\n dtype=np.uint16,\n )\n features = np.zeros((len(output_rows), steps, 3), dtype=np.float16)\n counts = np.zeros(len(output_rows), dtype=np.int32)\n for local_row, sequence_row in enumerate(rows):\n if sequence_row < 0:\n continue\n count = min(steps, max(int(group_lengths[local_row]) - start, 0))\n if not count:\n continue\n offset = int(prepared.offsets[sequence_row])\n selected = slice(offset + start, offset + start + count)\n items[local_row, :count] = prepared.sequence_items[selected]\n features[local_row, :count] = prepared.event_features[selected]\n counts[local_row] = count\n outputs, _ = event_sequence(\n model,\n torch.from_numpy(items.astype(np.int64)).to(device),\n torch.from_numpy(features.astype(np.float32)).to(device),\n hidden,\n )\n next_rows: list[torch.Tensor] = []\n for local_row, count in enumerate(counts):\n next_rows.append(\n outputs[local_row, count - 1]\n if count\n else hidden[0, local_row]\n )\n hidden = torch.stack(next_rows).unsqueeze(0)\n\n liked_items = torch.from_numpy(\n prepared.inference_liked_items[output_rows].astype(np.int64)\n ).to(device)\n disliked_items = torch.from_numpy(\n prepared.inference_disliked_items[output_rows].astype(np.int64)\n ).to(device)\n queries = user_queries(\n model,\n hidden.squeeze(0),\n model._mean_context_channel(liked_items),\n model._mean_context_channel(disliked_items),\n torch.from_numpy(\n prepared.inference_user_features[output_rows].astype(np.float32)\n ).to(device),\n )\n result[torch.from_numpy(output_rows.astype(np.int64))] = queries.cpu()\n return result\n\n\n@torch.inference_mode()\ndef rank_candidates(\n model: base.SequentialTwoTower,\n prepared: SequenceData,\n eligibility: CandidateSet,\n config: Config,\n device: torch.device,\n ranking_batch_size: int,\n) -> tuple[pd.DataFrame, dict[str, float]]:\n model.eval()\n queries = inference_queries(model, prepared, config, device)\n item_parts: list[torch.Tensor] = []\n for start in range(0, len(prepared.item_ids), 2_048):\n rows = torch.arange(\n start,\n min(start + 2_048, len(prepared.item_ids)),\n dtype=torch.long,\n device=device,\n )\n item_parts.append(model.encode_items(rows).cpu())\n items = torch.cat(item_parts)\n rows: list[tuple[int, int, int]] = []\n for start in range(0, len(eligibility.uids), ranking_batch_size):\n end = min(start + ranking_batch_size, len(eligibility.uids))\n scores = queries[start:end] @ items.T\n eligible = np.unpackbits(\n eligibility.packed[start:end],\n axis=1,\n count=len(prepared.item_ids),\n bitorder=\"little\",\n ).astype(bool, copy=False)\n scores.masked_fill_(~torch.from_numpy(eligible), -torch.inf)\n selected = torch.topk(scores, k=base.TOP_N, dim=1).indices.numpy()\n for local_row, columns in enumerate(selected):\n uid = int(eligibility.uids[start + local_row])\n rows.extend(\n (uid, int(prepared.item_ids[column]), rank)\n for rank, column in enumerate(columns, start=1)\n )\n if end == len(eligibility.uids) or end % 1_024 == 0:\n log(f\"ranked users={end:,}/{len(eligibility.uids):,}\")\n query_norm = torch.linalg.vector_norm(queries, dim=1).numpy()\n item_norm = torch.linalg.vector_norm(items, dim=1).numpy()\n diagnostics = {\n \"query_norm_mean\": float(query_norm.mean()),\n \"query_norm_std\": float(query_norm.std()),\n \"item_norm_mean\": float(item_norm.mean()),\n \"item_norm_std\": float(item_norm.std()),\n }\n return pd.DataFrame(rows, columns=[\"uid\", \"item_id\", \"rank\"]), diagnostics\n\n\ndef write_ranking(frame: pd.DataFrame, output: Path) -> None:\n output.parent.mkdir(parents=True, exist_ok=True)\n if output.suffix == \".parquet\":\n frame.to_parquet(output, index=False, compression=\"zstd\")\n elif output.suffix == \".csv\":\n frame.to_csv(output, index=False)\n else:\n raise ValueError(\"--output must end in .parquet or .csv\")\n\n\ndef main() -> int:\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument(\n \"--stage\", choices=(\"validation\", \"submission\"), default=\"validation\"\n )\n parser.add_argument(\"--output\", type=Path, required=True)\n parser.add_argument(\"--public-dir\", type=Path, required=True)\n parser.add_argument(\"--prepared-cache\", type=Path)\n parser.add_argument(\"--device\", choices=(\"cpu\", \"mps\"), default=\"cpu\")\n parser.add_argument(\"--threads\", type=int, default=8)\n parser.add_argument(\"--bptt-steps\", type=int, default=Config.bptt_steps)\n parser.add_argument(\n \"--user-batch-size\", type=int, default=Config.user_batch_size\n )\n parser.add_argument(\"--epochs\", type=int, default=Config.epochs)\n parser.add_argument(\"--learning-rate\", type=float, default=Config.learning_rate)\n parser.add_argument(\n \"--loss-microbatch-size\",\n type=int,\n default=Config.loss_microbatch_size,\n )\n parser.add_argument(\n \"--negative-filter-scope\",\n choices=(\"full-training-history\", \"last-100\"),\n default=Config.negative_filter_scope,\n )\n parser.add_argument(\n \"--uniform-negatives\",\n type=int,\n default=Config.uniform_negatives,\n )\n parser.add_argument(\n \"--inbatch-negatives\",\n type=int,\n default=Config.inbatch_negatives,\n )\n parser.add_argument(\n \"--inbatch-correction-power\",\n type=float,\n default=Config.inbatch_correction_power,\n )\n parser.add_argument(\n \"--inbatch-correction-min\",\n type=float,\n default=Config.inbatch_correction_min,\n )\n parser.add_argument(\n \"--inbatch-correction-max\",\n type=float,\n default=Config.inbatch_correction_max,\n )\n parser.add_argument(\n \"--target-weighting\",\n choices=(\"discovery-graded\", \"organic-strong\", \"uniform\"),\n default=Config.target_weighting,\n )\n parser.add_argument(\n \"--loss-type\",\n choices=(\"infonce\", \"bce\"),\n default=Config.loss_type,\n )\n parser.add_argument(\n \"--temperature\",\n type=float,\n default=Config.temperature,\n )\n parser.add_argument(\n \"--ordinary-target-weight\",\n type=float,\n default=Config.ordinary_target_weight,\n )\n parser.add_argument(\n \"--organic-strong-target-weight\",\n type=float,\n default=Config.organic_strong_target_weight,\n )\n parser.add_argument(\n \"--organic-like-target-weight\",\n type=float,\n default=Config.organic_like_target_weight,\n )\n parser.add_argument(\n \"--discovery-horizon-days\",\n type=int,\n default=Config.discovery_horizon_days,\n )\n parser.add_argument(\n \"--validation-fraction\",\n type=float,\n default=Config.validation_fraction,\n )\n parser.add_argument(\n \"--max-train-targets-per-user\",\n type=int,\n default=Config.max_train_targets_per_user,\n help=\"retain this many recent pre-validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--max-validation-targets-per-user\",\n type=int,\n default=Config.max_validation_targets_per_user,\n help=\"retain this many final validation targets per user; 0 is uncapped\",\n )\n parser.add_argument(\n \"--early-stopping-patience\",\n type=int,\n default=Config.early_stopping_patience,\n )\n parser.add_argument(\n \"--early-stopping-min-delta\",\n type=float,\n default=Config.early_stopping_min_delta,\n )\n parser.add_argument(\"--checkpoint-dir\", type=Path)\n parser.add_argument(\"--resume-checkpoint\", type=Path)\n parser.add_argument(\"--seed\", type=int, default=Config.seed)\n parser.add_argument(\"--ranking-batch-size\", type=int, default=64)\n parser.add_argument(\"--prepare-only\", action=\"store_true\")\n args = parser.parse_args()\n\n if args.threads < 1 or args.bptt_steps < 2 or args.user_batch_size < 1:\n parser.error(\"threads, BPTT steps, and user batch size must be positive\")\n if (\n args.epochs < 1\n or args.learning_rate <= 0\n or args.loss_microbatch_size < 1\n or args.early_stopping_patience < 1\n or args.early_stopping_min_delta < 0\n or args.ordinary_target_weight <= 0\n or args.organic_strong_target_weight <= 0\n or args.organic_like_target_weight <= 0\n or args.discovery_horizon_days < 1\n or args.max_train_targets_per_user < 0\n or args.max_validation_targets_per_user < 0\n ):\n parser.error(\"training counts, learning rate, and patience are invalid\")\n if not 0.0 < args.validation_fraction < 1.0:\n parser.error(\"validation fraction must be strictly between zero and one\")\n public = args.public_dir.resolve()\n if not (public / \"data\" / \"candidate_catalog.parquet\").is_file():\n parser.error(f\"public task data not found under {public}\")\n config = Config(\n bptt_steps=args.bptt_steps,\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n uniform_negatives=args.uniform_negatives,\n inbatch_negatives=args.inbatch_negatives,\n inbatch_correction_power=args.inbatch_correction_power,\n inbatch_correction_min=args.inbatch_correction_min,\n inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n organic_like_target_weight=args.organic_like_target_weight,\n discovery_horizon_days=args.discovery_horizon_days,\n validation_fraction=args.validation_fraction,\n max_train_targets_per_user=args.max_train_targets_per_user,\n max_validation_targets_per_user=args.max_validation_targets_per_user,\n early_stopping_patience=args.early_stopping_patience,\n early_stopping_min_delta=args.early_stopping_min_delta,\n seed=args.seed,\n )\n torch.set_num_threads(args.threads)\n torch.set_num_interop_threads(1)\n seed_everything(config.seed)\n device = torch.device(args.device)\n if device.type == \"mps\" and not torch.backends.mps.is_available():\n parser.error(\"MPS was requested but is unavailable\")\n\n started = time.monotonic()\n prepared, eligibility = load_or_prepare(\n public,\n args.stage,\n config,\n args.prepared_cache.resolve() if args.prepared_cache else None,\n )\n target_partition = chronological_target_partition(\n prepared,\n config.validation_fraction,\n config.max_train_targets_per_user,\n config.max_validation_targets_per_user,\n )\n if args.prepare_only:\n print(\n json.dumps(\n {\n \"stage\": args.stage,\n \"sequence_users\": len(prepared.user_ids),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(\n target_partition.window_starts.sum()\n ),\n \"target_users\": len(eligibility.uids),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"config\": asdict(config),\n },\n indent=2,\n )\n )\n return 0\n\n model, training_history = train_model(\n public,\n args.stage,\n prepared,\n config,\n device,\n args.checkpoint_dir.resolve() if args.checkpoint_dir else None,\n args.resume_checkpoint.resolve() if args.resume_checkpoint else None,\n )\n ranking, embedding_diagnostics = rank_candidates(\n model,\n prepared,\n eligibility,\n config,\n device,\n args.ranking_batch_size,\n )\n write_ranking(ranking, args.output.resolve())\n print(\n json.dumps(\n {\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": args.stage,\n \"output\": str(args.output.resolve()),\n \"rows\": len(ranking),\n \"users\": int(ranking.uid.nunique()),\n \"runtime_seconds\": round(time.monotonic() - started, 3),\n \"public_inputs_only\": True,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": (\n \"every-adjacent-target-within-recent-chronological-window\"\n ),\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": False,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": (\n \"24-uniform-plus-8-propensity-corrected-inbatch\"\n ),\n \"false_negative_filter\": config.negative_filter_scope,\n \"target_weighting\": config.target_weighting,\n },\n \"config\": asdict(config),\n \"sequence_tokens\": len(prepared.sequence_items),\n \"all_next_item_targets\": prepared.target_count,\n \"selected_training_targets\": int(\n target_partition.training_counts.sum()\n ),\n \"selected_validation_targets\": int(\n target_partition.validation_counts.sum()\n ),\n \"discarded_old_targets\": int(target_partition.window_starts.sum()),\n \"training_history\": training_history,\n \"embedding_diagnostics\": embedding_diagnostics,\n \"torch_version\": torch.__version__,\n \"device\": str(device),\n },\n indent=2,\n )\n )\n return 0\n\n\nif __name__ == \"__main__\":\n raise SystemExit(main())\n",
"diffStat": {
"model_added_lines": 5,
"model_removed_lines": 0,
"model_added_chars": 279,
"model_removed_chars": 0,
"user_added_lines": 0,
"user_removed_lines": 0,
"user_added_chars": 0,
"user_removed_chars": 0
},
"isNewFile": false,
"isBuildFile": false
},
"description": "solution/train_current_model.py: negative_filter_scope=... => negative_filter_scope=...",
"displayName": "Edit",
"renderOutputAsMarkdown": true
},
"result": {
"timestamp": "2026-09-29T06:30:33.601Z",
"content": "Successfully modified file: /app/solution/train_current_model.py (1 replacements). Here is the updated code:\n...\n user_batch_size=args.user_batch_size,\n epochs=args.epochs,\n learning_rate=args.learning_rate,\n loss_microbatch_size=args.loss_microbatch_size,\n negative_filter_scope=args.negative_filter_scope,\n uniform_negatives=args.uniform_negatives,\n inbatch_negatives=args.inbatch_negatives,\n inbatch_correction_power=args.inbatch_correction_power,\n inbatch_correction_min=args.inbatch_correction_min,\n inbatch_correction_max=args.inbatch_correction_max,\n target_weighting=args.target_weighting,\n loss_type=args.loss_type,\n temperature=args.temperature,\n ordinary_target_weight=args.ordinary_target_weight,\n organic_strong_target_weight=args.organic_strong_target_weight,\n...",
"isError": false
},
"responseMessageId": "3a1745ce-1962-428d-8237-89adc3bea8c4"
}
]
},
{
"id": 61,
"role": "agent",
"timestamp": "2026-09-29T06:30:38.557Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:30:38.557Z",
"text": "Exploring Negative Sampling\n\nI'm currently investigating the impact of varying negative sampling strategies, specifically focusing on the interplay between `inbatch_negatives` and `uniform_negatives`. My current exploration involves increasing the quantity of in-batch negatives to observe its effect on model performance."
},
{
"kind": "tool",
"timestamp": "2026-09-29T06:30:38.557Z",
"callId": "run_shell_command__call_172492",
"name": "run_shell_command",
"input": {
"description": "Test with uniform=16 inbatch=16 negatives",
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type bce \\\n --uniform-negatives 16 \\\n --inbatch-negatives 16 \\\n --output /app/solution/exp4_u16_ib16.parquet && \\\npython /task/evaluate_public.py /app/solution/exp4_u16_ib16.parquet"
},
"recorded": {
"id": "run_shell_command__call_172492",
"name": "run_shell_command",
"args": {
"description": "Test with uniform=16 inbatch=16 negatives",
"command": "python /app/solution/train_current_model.py \\\n --stage validation \\\n --public-dir /task \\\n --prepared-cache /app/solution/validation_cache.npz \\\n --target-weighting discovery-graded \\\n --loss-type bce \\\n --uniform-negatives 16 \\\n --inbatch-negatives 16 \\\n --output /app/solution/exp4_u16_ib16.parquet && \\\npython /task/evaluate_public.py /app/solution/exp4_u16_ib16.parquet"
},
"result": [
{
"functionResponse": {
"id": "run_shell_command__call_172492",
"name": "run_shell_command",
"response": {
"output": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.556066 running_bce=0.556343 elapsed=190.2s\nepoch=1/1 train_loss=0.55431 validation_loss=0.52006 pair_accuracy=0.726 train_targets=1,052,953 validation_targets=130,103 train_seconds=203.0 validation_seconds=13.7\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520058\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 309.606,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 16,\n \"inbatch_negatives\": 16,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5543083887019831,\n \"positive_logit\": 0.6960524660219143,\n \"negative_logit\": -0.5012892177810132,\n \"pair_accuracy\": 0.7255772574844271,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 202.97917069799996,\n \"validation_loss\": 0.5200578049660878,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 13.70762099400008\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7176122665405273,\n \"query_norm_std\": 0.8431686758995056,\n \"item_norm_mean\": 1.8370518684387207,\n \"item_norm_std\": 0.7449614405632019\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.020984,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2340\n"
}
}
}
],
"status": "success",
"timestamp": "2026-09-29T06:35:55.814Z",
"resultDisplay": "loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.556066 running_bce=0.556343 elapsed=190.2s\nepoch=1/1 train_loss=0.55431 validation_loss=0.52006 pair_accuracy=0.726 train_targets=1,052,953 validation_targets=130,103 train_seconds=203.0 validation_seconds=13.7\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520058\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 309.606,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 16,\n \"inbatch_negatives\": 16,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5543083887019831,\n \"positive_logit\": 0.6960524660219143,\n \"negative_logit\": -0.5012892177810132,\n \"pair_accuracy\": 0.7255772574844271,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 202.97917069799996,\n \"validation_loss\": 0.5200578049660878,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 13.70762099400008\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7176122665405273,\n \"query_norm_std\": 0.8431686758995056,\n \"item_norm_mean\": 1.8370518684387207,\n \"item_norm_std\": 0.7449614405632019\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.020984,\n \"quality_users\": 4263\n }\n}",
"description": "Test with uniform=16 inbatch=16 negatives",
"displayName": "Shell",
"renderOutputAsMarkdown": false
},
"result": {
"timestamp": "2026-09-29T06:35:57.185Z",
"content": "\nOutput: loaded full-sequence cache: tokens=20,056,329 targets=20,047,194\nchronological BCE window: train=1,052,953 validation=130,103 selected=1,183,056 discarded_old_targets=18,864,138 all=20,047,194\ninbatch correction: min=0.250 mean_on_targets=1.001 max=4.000\nloaded organic-like outcomes: rows=301,527 users=7,526\ngrade-3 first-encounter targets=46,417 horizon_days=7\ntarget weighting=discovery-graded min=0.250 mean=0.310 max=3.000\nfull-history false-negative filter: users=9,135 unique_user_items=5,524,275 bytes=34,256,250\nepoch=1/1 batches=250 targets=987,417 batch_bce=0.556066 running_bce=0.556343 elapsed=190.2s\nepoch=1/1 train_loss=0.55431 validation_loss=0.52006 pair_accuracy=0.726 train_targets=1,052,953 validation_targets=130,103 train_seconds=203.0 validation_seconds=13.7\nrestored best validation-BCE checkpoint: epoch=1 loss=0.520058\nranked users=1,024/8,456\nranked users=2,048/8,456\nranked users=3,072/8,456\nranked users=4,096/8,456\nranked users=5,120/8,456\nranked users=6,144/8,456\nranked users=7,168/8,456\nranked users=8,192/8,456\nranked users=8,456/8,456\n{\n \"baseline\": \"yambda-windowed-sequence-two-tower-base\",\n \"stage\": \"validation\",\n \"output\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"rows\": 845600,\n \"users\": 8456,\n \"runtime_seconds\": 309.606,\n \"public_inputs_only\": true,\n \"architecture\": {\n \"family\": \"pure-windowed-sequence-two-tower\",\n \"sequence_training\": \"every-adjacent-target-within-recent-chronological-window\",\n \"sequence_encoder\": \"one-layer-GRU-dense-timestep-loss\",\n \"bptt_hidden_state\": \"carried-and-detached\",\n \"model_selection\": \"chronological-validation-BCE-early-stopping\",\n \"loss_execution\": \"gradient-accumulated-microbatches\",\n \"user_id_embedding\": false,\n \"user_mlp\": \"582-512-256-192\",\n \"item_mlp\": \"196-512-256-192\",\n \"normalization\": \"none\",\n \"score\": \"raw-dot-product\",\n \"objective\": \"sample-weighted-BCE-at-every-timestep\",\n \"negative_sampling\": \"24-uniform-plus-8-propensity-corrected-inbatch\",\n \"false_negative_filter\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\"\n },\n \"config\": {\n \"bptt_steps\": 100,\n \"user_batch_size\": 64,\n \"embedding_dim\": 192,\n \"hidden_dim\": 192,\n \"user_hidden_1\": 512,\n \"user_hidden_2\": 256,\n \"item_hidden_1\": 512,\n \"item_hidden_2\": 256,\n \"dropout\": 0.05,\n \"epochs\": 1,\n \"learning_rate\": 0.001,\n \"weight_decay\": 1e-05,\n \"gradient_clip\": 2.0,\n \"loss_microbatch_size\": 65536,\n \"uniform_negatives\": 16,\n \"inbatch_negatives\": 16,\n \"inbatch_correction_power\": 0.5,\n \"inbatch_correction_min\": 0.25,\n \"inbatch_correction_max\": 4.0,\n \"negative_filter_scope\": \"full-training-history\",\n \"target_weighting\": \"discovery-graded\",\n \"loss_type\": \"bce\",\n \"temperature\": 0.1,\n \"ordinary_target_weight\": 0.25,\n \"organic_strong_target_weight\": 1.0,\n \"organic_like_target_weight\": 3.0,\n \"discovery_horizon_days\": 7,\n \"validation_fraction\": 0.1,\n \"max_train_targets_per_user\": 128,\n \"max_validation_targets_per_user\": 16,\n \"early_stopping_patience\": 1,\n \"early_stopping_min_delta\": 0.0001,\n \"seed\": 29\n },\n \"sequence_tokens\": 20056329,\n \"all_next_item_targets\": 20047194,\n \"selected_training_targets\": 1052953,\n \"selected_validation_targets\": 130103,\n \"discarded_old_targets\": 18864138,\n \"training_history\": [\n {\n \"epoch\": 1.0,\n \"loss\": 0.5543083887019831,\n \"positive_logit\": 0.6960524660219143,\n \"negative_logit\": -0.5012892177810132,\n \"pair_accuracy\": 0.7255772574844271,\n \"targets\": 1052953.0,\n \"target_weight_sum\": 348780.0,\n \"batches\": 266.0,\n \"seconds\": 202.97917069799996,\n \"validation_loss\": 0.5200578049660878,\n \"validation_targets\": 130103.0,\n \"validation_target_weight_sum\": 42129.5,\n \"validation_seconds\": 13.70762099400008\n }\n ],\n \"embedding_diagnostics\": {\n \"query_norm_mean\": 1.7176122665405273,\n \"query_norm_std\": 0.8431686758995056,\n \"item_norm_mean\": 1.8370518684387207,\n \"item_norm_std\": 0.7449614405632019\n },\n \"torch_version\": \"2.8.0+cpu\",\n \"device\": \"cpu\"\n}\n{\n \"model\": \"/app/solution/exp4_u16_ib16.parquet\",\n \"scores\": {\n \"quality_ndcg@10\": 0.020984,\n \"quality_users\": 4263\n }\n}\nProcess Group PGID: 2340\n",
"isError": false
},
"responseMessageId": "d1ae6c74-9ec3-40bc-9486-19ef8b735b38"
}
]
},
{
"id": 62,
"role": "agent",
"timestamp": "2026-09-29T06:36:04.914Z",
"blocks": [
{
"kind": "reasoning",
"representation": "summary",
"timestamp": "2026-09-29T06:36:04.914Z",
"text": "Analyzing NDCG Performance\n\nI'm investigating the recent NDCG results, specifically noting the dip with increasing `inbatch` size and its impact on pair accuracy. It seems the harder in-batch negatives are a contributing factor, and I'm currently exploring how `inbatch_correction` might be influencing this."
}
]
}
],
"source": {
"format": "gemini-cli-session",
"sha256": "1f0d5e255fc13e52c8690d1311d7c5a2da07c503117572ae664c688d87c1a578",
"records": 301,
"sessionMetadata": {
"sessionId": "5b21a254-66d2-4985-a371-9459e907571a",
"projectHash": "f53b52ad6d21cceb72dfa78fb67614fe14f110c58e68412b01508d6a485501c3",
"startTime": "2026-09-29T05:36:37.308Z",
"lastUpdated": "2026-09-29T05:36:37.308Z",
"kind": "main"
},
"sessionUpdates": 121,
"usageRecords": [
{
"messageId": "e7660d2c-2bff-4e9b-8538-0a63dd6d540c",
"timestamp": "2026-09-29T05:36:43.270Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 10563,
"output": 129,
"cached": 7676,
"thoughts": 535,
"tool": 0,
"total": 11227
}
},
{
"messageId": "2dc0ab9a-89e9-4505-8db5-81581aad75f6",
"timestamp": "2026-09-29T05:36:45.647Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 12341,
"output": 41,
"cached": 7716,
"thoughts": 21,
"tool": 0,
"total": 12403
}
},
{
"messageId": "97fcf15d-ad9c-4d62-87b1-c8223f3e1eca",
"timestamp": "2026-09-29T05:36:47.358Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 12456,
"output": 54,
"cached": 7705,
"thoughts": 19,
"tool": 0,
"total": 12529
}
},
{
"messageId": "0eff30a7-703f-4794-b940-3d4a3746d73c",
"timestamp": "2026-09-29T05:36:52.183Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 12576,
"output": 31,
"cached": 7694,
"thoughts": 92,
"tool": 0,
"total": 12699
}
},
{
"messageId": "3be3f21e-cd71-4bf4-9e4d-2f6c7efb678b",
"timestamp": "2026-09-29T05:37:04.132Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 14223,
"output": 31,
"cached": 7736,
"thoughts": 13,
"tool": 0,
"total": 14267
}
},
{
"messageId": "906ce516-b532-45f5-a1ee-607cf6ac8200",
"timestamp": "2026-09-29T05:37:05.924Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 16523,
"output": 45,
"cached": 11679,
"thoughts": 26,
"tool": 0,
"total": 16594
}
},
{
"messageId": "1bc04a15-631b-47b9-82c6-dc517af9facf",
"timestamp": "2026-09-29T05:37:08.257Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 18801,
"output": 47,
"cached": 15645,
"thoughts": 31,
"tool": 0,
"total": 18879
}
},
{
"messageId": "40e0813e-9af0-474c-88d9-ce5d4af964b7",
"timestamp": "2026-09-29T05:37:10.693Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 21713,
"output": 30,
"cached": 15722,
"thoughts": 100,
"tool": 0,
"total": 21843
}
},
{
"messageId": "73683ae6-4dd8-46ef-a192-1bac9899e0ea",
"timestamp": "2026-09-29T05:37:13.446Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 22806,
"output": 45,
"cached": 19670,
"thoughts": 160,
"tool": 0,
"total": 23011
}
},
{
"messageId": "dda5b25b-34f4-4902-a272-cc4a82006d2d",
"timestamp": "2026-09-29T05:37:15.847Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 24753,
"output": 47,
"cached": 19711,
"thoughts": 101,
"tool": 0,
"total": 24901
}
},
{
"messageId": "35f995b8-4e98-48e2-8b90-e648191116a2",
"timestamp": "2026-09-29T05:37:18.075Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 27271,
"output": 48,
"cached": 23714,
"thoughts": 26,
"tool": 0,
"total": 27345
}
},
{
"messageId": "3ef44cd7-3f73-4bf0-96d2-cba3c33a4441",
"timestamp": "2026-09-29T05:37:20.105Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 29964,
"output": 49,
"cached": 23769,
"thoughts": 26,
"tool": 0,
"total": 30039
}
},
{
"messageId": "9db6079f-55d9-4a12-b5a0-cca93ee04015",
"timestamp": "2026-09-29T05:37:22.072Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 33779,
"output": 49,
"cached": 27813,
"thoughts": 26,
"tool": 0,
"total": 33854
}
},
{
"messageId": "a13b4e70-9e78-4d37-ae91-6877917e812b",
"timestamp": "2026-09-29T05:37:24.101Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 36322,
"output": 49,
"cached": 31831,
"thoughts": 26,
"tool": 0,
"total": 36397
}
},
{
"messageId": "d686b8d5-5b11-4d8a-9e1b-77530a2612e0",
"timestamp": "2026-09-29T05:37:28.032Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 40634,
"output": 49,
"cached": 35896,
"thoughts": 25,
"tool": 0,
"total": 40708
}
},
{
"messageId": "46c5cd9d-c10f-4d6f-9b82-ae9a53dc861b",
"timestamp": "2026-09-29T05:37:30.997Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 42639,
"output": 66,
"cached": 39910,
"thoughts": 154,
"tool": 0,
"total": 42859
}
},
{
"messageId": "50b99027-2378-4135-983c-d893b7dff2df",
"timestamp": "2026-09-29T05:37:37.854Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 43310,
"output": 47,
"cached": 39903,
"thoughts": 83,
"tool": 0,
"total": 43440
}
},
{
"messageId": "4f1abd24-6176-4713-b906-efbdfc4a8d43",
"timestamp": "2026-09-29T05:37:43.070Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 44172,
"output": 93,
"cached": 39900,
"thoughts": 264,
"tool": 0,
"total": 44529
}
},
{
"messageId": "e0501c5f-c779-40a9-8b04-7b440219de86",
"timestamp": "2026-09-29T05:43:54.305Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 46786,
"output": 45,
"cached": 7987,
"thoughts": 17,
"tool": 0,
"total": 46848
}
},
{
"messageId": "c7815475-b7b2-443e-9879-07766d5fdc01",
"timestamp": "2026-09-29T05:44:00.316Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 46934,
"output": 39,
"cached": 43909,
"thoughts": 99,
"tool": 0,
"total": 47072
}
},
{
"messageId": "10581a8f-dedf-40ed-9584-f32837f89f1c",
"timestamp": "2026-09-29T05:44:02.406Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 47169,
"output": 30,
"cached": 43891,
"thoughts": 55,
"tool": 0,
"total": 47254
}
},
{
"messageId": "4a73c496-7dd5-4efc-9248-fa937065cd95",
"timestamp": "2026-09-29T05:44:39.526Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 47311,
"output": 143,
"cached": 43871,
"thoughts": 1064,
"tool": 0,
"total": 48518
}
},
{
"messageId": "aa60f251-2261-433e-9dd4-d39fbe391f5a",
"timestamp": "2026-09-29T05:44:53.406Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 50644,
"output": 26,
"cached": 43903,
"thoughts": 2025,
"tool": 0,
"total": 52695
}
},
{
"messageId": "f956c851-1001-4d16-8293-56fde6f2e4d8",
"timestamp": "2026-09-29T05:45:05.006Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 53551,
"output": 47,
"cached": 47939,
"thoughts": 226,
"tool": 0,
"total": 53824
}
},
{
"messageId": "af43ade6-a5d1-4bd9-b5a1-5b80d6630ca8",
"timestamp": "2026-09-29T05:45:07.673Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 55012,
"output": 47,
"cached": 51944,
"thoughts": 25,
"tool": 0,
"total": 55084
}
},
{
"messageId": "48083088-4508-4511-9a7d-995895a74bce",
"timestamp": "2026-09-29T05:46:15.252Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 56763,
"output": 25,
"cached": 51960,
"thoughts": 4207,
"tool": 0,
"total": 60995
}
},
{
"messageId": "eb75e4f8-0981-41ad-9108-76f33902c221",
"timestamp": "2026-09-29T05:47:03.476Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 62975,
"output": 263,
"cached": 56068,
"thoughts": 6592,
"tool": 0,
"total": 69830
}
},
{
"messageId": "e8ff9a53-9345-496c-bab8-04bbeddbffa2",
"timestamp": "2026-09-29T05:47:16.229Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 70109,
"output": 340,
"cached": 64199,
"thoughts": 136,
"tool": 0,
"total": 70585
}
},
{
"messageId": "795685e1-0075-470e-b456-f9fe906ff109",
"timestamp": "2026-09-29T05:47:21.918Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 70651,
"output": 393,
"cached": 68198,
"thoughts": 12,
"tool": 0,
"total": 71056
}
},
{
"messageId": "6d66c487-d416-4413-a3fa-b5e9b8391d61",
"timestamp": "2026-09-29T05:47:53.449Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 71313,
"output": 32,
"cached": 68187,
"thoughts": 3666,
"tool": 0,
"total": 75011
}
},
{
"messageId": "b28dfefa-9199-400a-8483-3a17978e5311",
"timestamp": "2026-09-29T05:48:04.407Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 75282,
"output": 657,
"cached": 68238,
"thoughts": 1014,
"tool": 0,
"total": 76953
}
},
{
"messageId": "af49b45d-7bb2-44d4-86fc-feb16e6c0e36",
"timestamp": "2026-09-29T05:48:18.765Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 77215,
"output": 163,
"cached": 72265,
"thoughts": 923,
"tool": 0,
"total": 78301
}
},
{
"messageId": "45a625a0-dd63-4ddd-9aea-5f351b9b03c3",
"timestamp": "2026-09-29T05:48:26.139Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 78640,
"output": 198,
"cached": 76282,
"thoughts": 89,
"tool": 0,
"total": 78927
}
},
{
"messageId": "2bfea883-1635-4258-a72c-e79a1a0e3d3d",
"timestamp": "2026-09-29T05:49:11.085Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 79239,
"output": 85,
"cached": 76269,
"thoughts": 6378,
"tool": 0,
"total": 85702
}
},
{
"messageId": "2446b749-3c37-4201-a281-83bfedf8782e",
"timestamp": "2026-09-29T05:49:36.073Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 85731,
"output": 268,
"cached": 76362,
"thoughts": 2831,
"tool": 0,
"total": 88830
}
},
{
"messageId": "a4b27055-13cb-4396-b1bc-21dd1f91fda6",
"timestamp": "2026-09-29T05:55:10.425Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 90915,
"output": 150,
"cached": 8042,
"thoughts": 103,
"tool": 0,
"total": 91168
}
},
{
"messageId": "b7f518c0-8eff-4faf-9201-f29e6689d0f5",
"timestamp": "2026-09-29T05:55:36.731Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 91227,
"output": 387,
"cached": 88445,
"thoughts": 1358,
"tool": 0,
"total": 92972
}
},
{
"messageId": "afa4d308-c381-46e4-b61f-61c1e0f4d690",
"timestamp": "2026-09-29T05:59:39.471Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 93073,
"output": 111,
"cached": 8041,
"thoughts": 2682,
"tool": 0,
"total": 95866
}
},
{
"messageId": "0d8a6303-a480-4002-99ad-8033962398eb",
"timestamp": "2026-09-29T06:01:46.504Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 96062,
"output": 47,
"cached": 8043,
"thoughts": 3411,
"tool": 0,
"total": 99520
}
},
{
"messageId": "661ce39a-fb4a-4417-9485-e4f80c3685b6",
"timestamp": "2026-09-29T06:04:35.020Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 100403,
"output": 184,
"cached": 92551,
"thoughts": 519,
"tool": 0,
"total": 101106
}
},
{
"messageId": "ab81d53d-18df-41d0-8579-9d8c5ada1732",
"timestamp": "2026-09-29T06:04:43.669Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 101112,
"output": 36,
"cached": 0,
"thoughts": 43,
"tool": 0,
"total": 101191
}
},
{
"messageId": "4129ef1c-2ae8-4c5f-b791-9e8b9e41e0b5",
"timestamp": "2026-09-29T06:04:47.317Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 101460,
"output": 59,
"cached": 96535,
"thoughts": 47,
"tool": 0,
"total": 101566
}
},
{
"messageId": "931e615f-b89c-48df-ade6-48351387ccb2",
"timestamp": "2026-09-29T06:05:03.781Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 101595,
"output": 172,
"cached": 96513,
"thoughts": 9,
"tool": 0,
"total": 101776
}
},
{
"messageId": "555684c6-4fc8-406d-92ca-db88c8184e27",
"timestamp": "2026-09-29T06:05:07.606Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 101962,
"output": 47,
"cached": 96486,
"thoughts": 48,
"tool": 0,
"total": 102057
}
},
{
"messageId": "7c24c5d2-3b44-4876-b94d-a9f5d817e8d0",
"timestamp": "2026-09-29T06:05:13.335Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 102540,
"output": 47,
"cached": 100491,
"thoughts": 50,
"tool": 0,
"total": 102637
}
},
{
"messageId": "9ab6c949-8adf-4926-a2a8-21a42207517b",
"timestamp": "2026-09-29T06:05:18.941Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 103921,
"output": 537,
"cached": 100492,
"thoughts": 56,
"tool": 0,
"total": 104514
}
},
{
"messageId": "086a0c88-5afc-48a0-961a-a9417cc358cb",
"timestamp": "2026-09-29T06:05:26.722Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 104886,
"output": 223,
"cached": 100475,
"thoughts": 21,
"tool": 0,
"total": 105130
}
},
{
"messageId": "71ad11f1-3210-4baa-aa9e-3b5b868a95cd",
"timestamp": "2026-09-29T06:05:30.090Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 105298,
"output": 47,
"cached": 100449,
"thoughts": 40,
"tool": 0,
"total": 105385
}
},
{
"messageId": "89f90cd5-2c5d-471b-9200-b3a0dc39ec3c",
"timestamp": "2026-09-29T06:05:34.574Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 105948,
"output": 173,
"cached": 100436,
"thoughts": 28,
"tool": 0,
"total": 106149
}
},
{
"messageId": "892f14cc-5935-4533-9ebf-690fe269cf0b",
"timestamp": "2026-09-29T06:05:41.078Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 106336,
"output": 159,
"cached": 100410,
"thoughts": 261,
"tool": 0,
"total": 106756
}
},
{
"messageId": "50e5ced6-d047-4e48-a8c3-70cfe7d035cc",
"timestamp": "2026-09-29T06:22:48.005Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 108754,
"output": 349,
"cached": 104447,
"thoughts": 3738,
"tool": 0,
"total": 112841
}
},
{
"messageId": "91a85fb6-0f78-459d-9d59-2ac91dd5c4e3",
"timestamp": "2026-09-29T06:22:52.495Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 112937,
"output": 143,
"cached": 108508,
"thoughts": 24,
"tool": 0,
"total": 113104
}
},
{
"messageId": "168426c9-cbd5-4641-a82f-b593d102687b",
"timestamp": "2026-09-29T06:29:55.860Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 115099,
"output": 152,
"cached": 112541,
"thoughts": 288,
"tool": 0,
"total": 115539
}
},
{
"messageId": "284c0f37-73a1-42c4-8ccd-09c413fabb60",
"timestamp": "2026-09-29T06:30:16.167Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 115598,
"output": 344,
"cached": 112526,
"thoughts": 2366,
"tool": 0,
"total": 118308
}
},
{
"messageId": "2f708c22-f9dd-4d86-ab11-24de8aa3f0c3",
"timestamp": "2026-09-29T06:30:22.494Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 118565,
"output": 47,
"cached": 0,
"thoughts": 211,
"tool": 0,
"total": 118823
}
},
{
"messageId": "56023512-3158-4c8b-a908-ac8cb922a6d9",
"timestamp": "2026-09-29T06:30:26.772Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 120416,
"output": 353,
"cached": 116573,
"thoughts": 61,
"tool": 0,
"total": 120830
}
},
{
"messageId": "c9e92dc1-f764-475b-9cc4-29882d986b2d",
"timestamp": "2026-09-29T06:30:30.363Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 121134,
"output": 47,
"cached": 116552,
"thoughts": 41,
"tool": 0,
"total": 121222
}
},
{
"messageId": "8e71b48c-63ae-442a-823e-be105f57f5e5",
"timestamp": "2026-09-29T06:30:33.585Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 121758,
"output": 208,
"cached": 116539,
"thoughts": 10,
"tool": 0,
"total": 121976
}
},
{
"messageId": "d3827be4-2d95-4577-a28d-19dcfe18506d",
"timestamp": "2026-09-29T06:30:38.557Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 122215,
"output": 174,
"cached": 116514,
"thoughts": 165,
"tool": 0,
"total": 122554
}
},
{
"messageId": "232ac6b3-618a-4297-bca8-aa8857cc49ab",
"timestamp": "2026-09-29T06:36:04.914Z",
"model": "gemini-3.8-flash",
"tokens": {
"input": 124554,
"output": 170,
"cached": 8036,
"thoughts": 275,
"tool": 0,
"total": 124999
}
}
]
}
}