From 53f04f5e56e6b63524a8f96fee36fc5f60a3a842 Mon Sep 17 00:00:00 2001 From: aliu65803 Date: Wed, 18 Nov 2026 13:54:45 -0600 Subject: [PATCH 1/5] Add KumoRelational fraud context-tuning example notebook Demonstrates four levers for rare-event fraud detection on synthetic accounts and transactions: rebalanced in-context examples, context ensembling, recency and neighbor sampling, and threshold tuning chosen on a validation window. Indexes the notebook in the Structured Data Models README. Co-Authored-By: Claude Opus 5.5 --- .../structured-data-models/README.md | 1 + ...odels_fraud_detection_context_tuning.ipynb | 1509 +++++++++++++++++ 2 files changed, 1510 insertions(+) create mode 100644 examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb diff --git a/examples/kumo-example-notebooks/structured-data-models/README.md b/examples/kumo-example-notebooks/structured-data-models/README.md index 9de5abf4b..965770960 100644 --- a/examples/kumo-example-notebooks/structured-data-models/README.md +++ b/examples/kumo-example-notebooks/structured-data-models/README.md @@ -27,6 +27,7 @@ Client examples require an existing endpoint; they do not provision one. | Example | Deployment | Scope | | --- | --- | --- | | [Screen synthetic accounts with client KumoRelational](relational/fsi/notebooks/local_structured_data_models_client_money_muling_detection.ipynb) | Local | Model workflow | +| [Improve fraud recall on imbalanced accounts by tuning context, sampling and threshold](relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb) | Local | Model workflow | ### Retail diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb new file mode 100644 index 000000000..7ca684cc0 --- /dev/null +++ b/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb @@ -0,0 +1,1509 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d40ab9c", + "metadata": {}, + "source": [ + "# Improve fraud recall on imbalanced accounts with KumoRelational\n", + "\n", + "Which accounts will be confirmed as fraud within 30 days? When fraud is rare, a pretrained relational model can rank accounts well but still flag almost none of them at the default 0.5 cutoff. This notebook applies four strategies to the in-context examples and the decision threshold, and measures the lift each one adds.\n", + "\n", + "Run locally with Python 3.12 or newer and [direct KumoRelational](https://nvidia.github.io/structured-data-models/api/generated/sdm.models.KumoRelational.html) from `structured-data-models`. A GPU is optional; on a laptop CPU the notebook takes about 20 minutes. The account and transaction tables are synthetic, and every metric is **demonstration only**.\n", + "\n", + "| Strategy | Lever |\n", + "| --- | --- |\n", + "| 1. Rebalance the context | Include every fraud example and test fraud-to-legitimate ratios, context sizes and fraud repetition. |\n", + "| 2. Ensemble across contexts | Keep the fraud examples fixed, vary the legitimate examples and average the predictions. |\n", + "| 3. Tune sampling | Prefer recent accounts, take each account's most recent transactions and vary the neighbor count. |\n", + "| 4. Tune the threshold | Choose the cutoff on validation data for maximum F1 or maximum recall at a target precision. |" + ] + }, + { + "cell_type": "markdown", + "id": "dcf7b0f0", + "metadata": {}, + "source": [ + "## Install and configure\n", + "\n", + "Install the packages into this notebook kernel. On CPU, relational sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the graph diagram needs the [Graphviz](https://graphviz.org/download/) system package. See [installation](https://nvidia.github.io/structured-data-models/install.html) for details." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ee72fcf3", + "metadata": {}, + "outputs": [], + "source": [ + "%pip install structured-data-models pandas pyarrow scikit-learn matplotlib graphviz" + ] + }, + { + "cell_type": "markdown", + "id": "aa783b9b", + "metadata": {}, + "source": [ + "## Set the example parameters\n", + "\n", + "The time boundaries split accounts into a context pool, a validation window for choosing settings, and a later test window for reporting lift. The baseline mirrors a common first run: a random context at the natural fraud rate with the default cutoff." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a5463b49", + "metadata": {}, + "outputs": [], + "source": [ + "SEED = 7\n", + "N_ACCOUNTS = 80_000\n", + "N_SCORING_ACCOUNTS = 2_000\n", + "FRAUD_RATE = 0.005\n", + "START = \"2026-01-01\"\n", + "HISTORY_DAYS = 90\n", + "VALIDATION_START_DAY = 270\n", + "TEST_START_DAY = 310\n", + "\n", + "BASELINE_CONTEXT_SIZE = 5_000\n", + "LARGE_CONTEXT_SIZE = 10_000\n", + "FRAUD_REPEAT = 10\n", + "NUM_ESTIMATORS = 5\n", + "RECENT_CONTEXT_DAYS = 90\n", + "NEIGHBOR_OPTIONS = [16, 32]\n", + "\n", + "DEFAULT_THRESHOLD = 0.5\n", + "TARGET_PRECISION = 0.5\n", + "OUTPUT_PARENT = None\n", + "CLEANUP = False" + ] + }, + { + "cell_type": "markdown", + "id": "1f7aa4e4", + "metadata": {}, + "source": [ + "Import the libraries, select a device and create a new directory for this run's outputs." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "593c0250", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx\n" + ] + } + ], + "source": [ + "import json\n", + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import sdm\n", + "import torch\n", + "from IPython.display import display\n", + "from sklearn.metrics import average_precision_score, f1_score, precision_recall_curve, precision_score, recall_score, roc_auc_score\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "rng = np.random.default_rng(SEED)\n", + "workspace = tempfile.TemporaryDirectory(prefix=\"fraud-context-tuning-\", dir=OUTPUT_PARENT, delete=False)\n", + "run_dir = Path(workspace.name)\n", + "print(\"Device:\", device, \"| Results:\", run_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "f46a046a", + "metadata": {}, + "source": [ + "## Generate synthetic example data\n", + "\n", + "Run the next cell to create accounts, card transactions and fraud labels, plus a separate set of new accounts reserved for batch scoring. You can skim the generation code; the Kumo workflow starts at **Build the relational data**.\n", + "\n", + "Each account has an observation date and 60 to 90 days of prior transactions. Most fraud accounts show a short burst of unusual activity in the final days before that date, and some legitimate accounts show similar bursts. The fraud pattern drifts mid-year from large daytime purchases to small, international, late-night purchases on new devices." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7fb12d07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
historical_rowsreserved_rows
accounts800002000
transactions224920755910
\n", + "
" + ], + "text/plain": [ + " historical_rows reserved_rows\n", + "accounts 80000 2000\n", + "transactions 2249207 55910" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraud rate: 0.53% (about 1 in 190)\n" + ] + } + ], + "source": [ + "PATTERNS = {\"early\": (6.0, 0.6, 0.15, 14, 4, 0.25), \"late\": (3.0, 0.6, 0.65, 2, 2, 0.55)}\n", + "DRIFT_DAY = 215\n", + "\n", + "\n", + "def simulate_transactions(account_ids, anchors, counts, window_days, amount_mu, amount_sd, intl_p, hour_mu, hour_sd, device_p):\n", + " owners = np.repeat(account_ids, counts)\n", + " return pd.DataFrame({\n", + " \"account_id\": owners,\n", + " \"timestamp\": np.repeat(anchors, counts) - pd.to_timedelta(rng.uniform(0, window_days, len(owners)), unit=\"D\"),\n", + " \"amount\": rng.lognormal(amount_mu, amount_sd, len(owners)).round(2),\n", + " \"is_international\": (rng.random(len(owners)) < intl_p).astype(float),\n", + " \"hour_of_day\": rng.normal(hour_mu, hour_sd, len(owners)).clip(0, 23).round(),\n", + " \"new_device\": (rng.random(len(owners)) < device_p).astype(float),\n", + " })\n", + "\n", + "\n", + "def simulate_accounts(account_ids, anchors):\n", + " n = len(account_ids)\n", + " is_fraud = rng.random(n) < FRAUD_RATE\n", + " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", + " accounts = pd.DataFrame({\n", + " \"account_id\": account_ids,\n", + " \"account_age_days\": np.where(is_fraud, rng.gamma(2.0, 150, n), rng.gamma(3.0, 300, n)).round(),\n", + " \"kyc_tier\": rng.integers(1, 4, n).astype(float),\n", + " })\n", + " parts = [simulate_transactions(account_ids, anchors.values, rng.poisson(24, n) + 4, HISTORY_DAYS, 3.5, 0.9, 0.05, 14, 4, 0.03)]\n", + " bursty_fraud = is_fraud & (rng.random(n) < 0.9)\n", + " lookalikes = ~is_fraud & (rng.random(n) < 0.03)\n", + " for mask, mean_count in ((bursty_fraud, 4), (lookalikes, 3)):\n", + " for period, selected in ((\"early\", mask & ~late), (\"late\", mask & late)):\n", + " parts.append(simulate_transactions(\n", + " account_ids[selected], anchors.values[selected], rng.poisson(mean_count, selected.sum()) + 1, 5, *PATTERNS[period]\n", + " ))\n", + " transactions = pd.concat(parts, ignore_index=True).sort_values(\"timestamp\", ignore_index=True)\n", + " transactions[\"timestamp\"] = transactions.timestamp.dt.floor(\"s\")\n", + " labels = pd.DataFrame({\"account_id\": account_ids, \"timestamp\": anchors, \"is_fraud\": np.where(is_fraud, \"fraud\", \"legit\")})\n", + " return accounts, transactions, labels\n", + "\n", + "\n", + "history_anchors = pd.Timestamp(START) + pd.to_timedelta(rng.integers(60, 365, N_ACCOUNTS), unit=\"D\")\n", + "accounts, transactions, labels = simulate_accounts(np.arange(N_ACCOUNTS), history_anchors)\n", + "transactions.insert(0, \"transaction_id\", np.arange(len(transactions)))\n", + "\n", + "scoring_anchors = pd.DatetimeIndex([pd.Timestamp(START) + pd.Timedelta(days=365)] * N_SCORING_ACCOUNTS)\n", + "new_accounts, new_transactions, _ = simulate_accounts(np.arange(N_ACCOUNTS, N_ACCOUNTS + N_SCORING_ACCOUNTS), scoring_anchors)\n", + "new_transactions.insert(0, \"transaction_id\", np.arange(len(transactions), len(transactions) + len(new_transactions)))\n", + "\n", + "display(pd.DataFrame({\n", + " \"historical_rows\": {\"accounts\": len(accounts), \"transactions\": len(transactions)},\n", + " \"reserved_rows\": {\"accounts\": len(new_accounts), \"transactions\": len(new_transactions)},\n", + "}))\n", + "print(f\"Fraud rate: {labels.is_fraud.eq('fraud').mean():.2%} (about 1 in {round(1 / labels.is_fraud.eq('fraud').mean())})\")" + ] + }, + { + "cell_type": "markdown", + "id": "2eab2259", + "metadata": {}, + "source": [ + "## Build the relational data\n", + "\n", + "Link transactions to accounts and convert both tables to tensors. KumoRelational uses numerical and datetime features, so the flags are stored as 0/1 numbers. The sampler uses transaction timestamps to keep every neighbor before the account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f96988be", + "metadata": {}, + "outputs": [], + "source": [ + "ACCOUNT_STYPES = {\"account_id\": \"id\", \"account_age_days\": \"numerical\", \"kyc_tier\": \"numerical\"}\n", + "TRANSACTION_STYPES = {\n", + " \"transaction_id\": \"id\", \"account_id\": \"id\", \"timestamp\": \"datetime\", \"amount\": \"numerical\",\n", + " \"is_international\": \"numerical\", \"hour_of_day\": \"numerical\", \"new_device\": \"numerical\",\n", + "}\n", + "RELATIONSHIPS = [{\"left_table\": \"transactions\", \"left_column\": \"account_id\", \"right_table\": \"accounts\", \"right_column\": \"account_id\"}]\n", + "TASK_LINK = {\"task_column\": \"account_id\", \"table\": \"accounts\", \"table_column\": \"account_id\"}\n", + "\n", + "\n", + "def build_relational_data(account_frame, transaction_frame):\n", + " return sdm.RelationalData(\n", + " tables={\n", + " \"accounts\": sdm.TableTensor.from_pandas(account_frame, stypes=ACCOUNT_STYPES),\n", + " \"transactions\": sdm.TableTensor.from_pandas(transaction_frame, stypes=TRANSACTION_STYPES),\n", + " },\n", + " relationships=RELATIONSHIPS,\n", + " )\n", + "\n", + "\n", + "data = build_relational_data(accounts, transactions)\n", + "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"is_fraud\": \"categorical\"})" + ] + }, + { + "cell_type": "markdown", + "id": "dc1be8ce", + "metadata": {}, + "source": [ + "Inspect the schema the model will traverse: each account links to its transactions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "01791271", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "accounts\n", + "\n", + "accounts\n", + "\n", + "account_id: id\n", + "account_age_days: numerical\n", + "kyc_tier: numerical\n", + "\n", + "\n", + "\n", + "transactions\n", + "\n", + "transactions\n", + "\n", + "transaction_id: id\n", + "account_id: id\n", + "timestamp: datetime\n", + "amount: numerical\n", + "is_international: numerical\n", + "hour_of_day: numerical\n", + "new_device: numerical\n", + "\n", + "\n", + "\n", + "transactions--accounts\n", + "\n", + " account_id <> account_id \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.to_graphviz()" + ] + }, + { + "cell_type": "markdown", + "id": "e4836b1d", + "metadata": {}, + "source": [ + "## Split accounts by time\n", + "\n", + "Accounts observed before day 270 form the labeled context pool. Validation accounts (days 270 to 309) are used only to choose settings and thresholds; test accounts (day 310 onward) report the result. This mirrors scoring future accounts with labeled history." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bb168100", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accountsfraud_accounts
context pool54882283
validation1056555
test1455382
\n", + "
" + ], + "text/plain": [ + " accounts fraud_accounts\n", + "context pool 54882 283\n", + "validation 10565 55\n", + "test 14553 82" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", + "is_fraud = labels.is_fraud.eq(\"fraud\").to_numpy()\n", + "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", + "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", + "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", + "fraud_pool = pool_rows[is_fraud[pool_rows]]\n", + "legit_pool = pool_rows[~is_fraud[pool_rows]]\n", + "y_val, y_test = is_fraud[val_rows], is_fraud[test_rows]\n", + "\n", + "display(pd.DataFrame({\n", + " \"accounts\": [len(pool_rows), len(val_rows), len(test_rows)],\n", + " \"fraud_accounts\": [is_fraud[pool_rows].sum(), y_val.sum(), y_test.sum()],\n", + "}, index=[\"context pool\", \"validation\", \"test\"]))" + ] + }, + { + "cell_type": "markdown", + "id": "2b3b63a9", + "metadata": {}, + "source": [ + "## Define the scoring and evaluation helpers\n", + "\n", + "`score_contexts` fits KumoRelational on each context, scores the query accounts and averages the fraud probability across contexts. A single context is an ensemble of one. `num_neighbors` and `temporal_strategy` control which transactions the [sampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html) attaches to each account." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bcf90983", + "metadata": {}, + "outputs": [], + "source": [ + "model = sdm.models.KumoRelational(device=device)\n", + "evaluation_query = task_table[torch.as_tensor(np.concatenate([val_rows, test_rows]))].drop_columns(\"is_fraud\")\n", + "\n", + "\n", + "def score_contexts(contexts, query, relational_sampler, num_neighbors=8, temporal_strategy=\"uniform\", batch_size=10_000):\n", + " options = dict(task_link=TASK_LINK, num_neighbors=[num_neighbors], task_time_column=\"timestamp\", temporal_strategy=temporal_strategy)\n", + " member_probabilities = []\n", + " for context_rows in contexts:\n", + " torch.manual_seed(SEED)\n", + " context, related = relational_sampler(task_table[torch.as_tensor(context_rows)], **options).to(device)\n", + " model.fit(x=context.drop_columns(\"is_fraud\"), y=context[\"is_fraud\"], related_tables=related)\n", + " batches = []\n", + " for query_batch in query.split(batch_size, -2):\n", + " out = model.predict(*relational_sampler(query_batch, **options).to(device))\n", + " batches.append(out.numerical[:, list(out.columns[sdm.Stype.numerical]).index(\"fraud\")].float().cpu().numpy())\n", + " member_probabilities.append(np.concatenate(batches))\n", + " return np.mean(member_probabilities, axis=0)\n", + "\n", + "\n", + "def score_evaluation(contexts, **options):\n", + " probabilities = score_contexts(contexts, evaluation_query, sampler, **options)\n", + " return probabilities[: len(val_rows)], probabilities[len(val_rows):]\n", + "\n", + "\n", + "def metrics(y_true, probability, threshold):\n", + " flagged = probability >= threshold\n", + " return {\n", + " \"average_precision\": average_precision_score(y_true, probability),\n", + " \"auroc\": roc_auc_score(y_true, probability),\n", + " \"precision\": precision_score(y_true, flagged, zero_division=0),\n", + " \"recall\": recall_score(y_true, flagged),\n", + " \"f1\": f1_score(y_true, flagged),\n", + " \"threshold\": threshold,\n", + " }\n", + "\n", + "\n", + "def compose_context(fraud_rows, legit_rows, n_legit, fraud_repeat=1):\n", + " return np.concatenate([np.tile(fraud_rows, fraud_repeat), rng.choice(legit_rows, n_legit, replace=False)])\n", + "\n", + "\n", + "stages = {}" + ] + }, + { + "cell_type": "markdown", + "id": "b79128ff", + "metadata": {}, + "source": [ + "## Score the baseline\n", + "\n", + "Draw a random context at the natural fraud rate, which contains only a few dozen fraud examples. Average precision and AUROC measure ranking quality without a threshold; precision, recall and F1 use the default 0.5 cutoff." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1e1b5aa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraud examples in the baseline context: 18 of 5000\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.00.00.00.5
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall f1 threshold\n", + "Baseline 0.035 0.852 0.0 0.0 0.0 0.5" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "baseline_context = rng.choice(pool_rows, BASELINE_CONTEXT_SIZE, replace=False)\n", + "baseline_val, baseline_test = score_evaluation([baseline_context])\n", + "stages[\"Baseline\"] = metrics(y_test, baseline_test, DEFAULT_THRESHOLD)\n", + "print(f\"Fraud examples in the baseline context: {is_fraud[baseline_context].sum()} of {BASELINE_CONTEXT_SIZE}\")\n", + "display(pd.DataFrame(stages).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "e4033d9a", + "metadata": {}, + "source": [ + "The ranking is reasonable, but with so few fraud examples the model rarely assigns a probability above 0.5, so recall is low. The next four strategies address this. Metrics are **demonstration only**.\n", + "\n", + "## Strategy 1: rebalance the in-context examples\n", + "\n", + "Every candidate includes all fraud accounts from the pool. The ratio candidates test 1:1, 1:5 and 1:20; the large candidate fills a 10,000-row context; the repeated candidate includes each fraud account ten times. Choose the candidate with the highest validation average precision." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7913d842", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
validation_average_precisionvalidation_recall_at_0.5validation_precision_at_0.5
1:10.3180.9090.028
1:50.3650.6730.119
1:200.3730.5090.311
All fraud, 10,000 rows0.3680.4910.281
Fraud x10, 10,000 rows0.3320.8360.062
\n", + "
" + ], + "text/plain": [ + " validation_average_precision \\\n", + "1:1 0.318 \n", + "1:5 0.365 \n", + "1:20 0.373 \n", + "All fraud, 10,000 rows 0.368 \n", + "Fraud x10, 10,000 rows 0.332 \n", + "\n", + " validation_recall_at_0.5 validation_precision_at_0.5 \n", + "1:1 0.909 0.028 \n", + "1:5 0.673 0.119 \n", + "1:20 0.509 0.311 \n", + "All fraud, 10,000 rows 0.491 0.281 \n", + "Fraud x10, 10,000 rows 0.836 0.062 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected context design: 1:20\n" + ] + } + ], + "source": [ + "n_fraud = len(fraud_pool)\n", + "context_designs = {\n", + " \"1:1\": (1, n_fraud),\n", + " \"1:5\": (1, 5 * n_fraud),\n", + " \"1:20\": (1, 20 * n_fraud),\n", + " f\"All fraud, {LARGE_CONTEXT_SIZE:,} rows\": (1, LARGE_CONTEXT_SIZE - n_fraud),\n", + " f\"Fraud x{FRAUD_REPEAT}, {LARGE_CONTEXT_SIZE:,} rows\": (FRAUD_REPEAT, LARGE_CONTEXT_SIZE - FRAUD_REPEAT * n_fraud),\n", + "}\n", + "design_scores = {}\n", + "for name, (fraud_repeat, n_legit) in context_designs.items():\n", + " design_val, design_test = score_evaluation([compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)])\n", + " design_scores[name] = (design_val, design_test)\n", + "\n", + "comparison = pd.DataFrame({\n", + " name: {\n", + " \"validation_average_precision\": average_precision_score(y_val, design_val),\n", + " \"validation_recall_at_0.5\": recall_score(y_val, design_val >= DEFAULT_THRESHOLD),\n", + " \"validation_precision_at_0.5\": precision_score(y_val, design_val >= DEFAULT_THRESHOLD, zero_division=0),\n", + " }\n", + " for name, (design_val, _) in design_scores.items()\n", + "}).T\n", + "best_design = comparison.validation_average_precision.idxmax()\n", + "fraud_repeat, n_legit = context_designs[best_design]\n", + "stages[\"+ Rebalanced context\"] = metrics(y_test, design_scores[best_design][1], DEFAULT_THRESHOLD)\n", + "display(comparison.round(3))\n", + "print(\"Selected context design:\", best_design)" + ] + }, + { + "cell_type": "markdown", + "id": "671b1ced", + "metadata": {}, + "source": [ + "Every rebalanced design ranks better than the baseline. Lower legitimate ratios also move probabilities upward, raising recall at 0.5 at the cost of precision. That shift is corrected in strategy 4, so the selection uses average precision, which ignores the cutoff.\n", + "\n", + "## Strategy 2: ensemble across contexts\n", + "\n", + "Keep the same fraud accounts in every context and draw a different set of legitimate accounts for each. Averaging the members reduces the variance that comes from any single draw of legitimate examples. See [ensembling in-context learners](https://nvidia.github.io/structured-data-models/icl.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9765b04c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation AP per member: [0.365 0.355 0.359 0.378 0.37 ]\n", + "Validation AP of the ensemble: 0.372\n" + ] + } + ], + "source": [ + "ensemble_contexts = [compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat) for _ in range(NUM_ESTIMATORS)]\n", + "member_scores = [score_evaluation([context]) for context in ensemble_contexts]\n", + "member_val_ap = [average_precision_score(y_val, member_val) for member_val, _ in member_scores]\n", + "ensemble_val = np.mean([member_val for member_val, _ in member_scores], axis=0)\n", + "ensemble_test = np.mean([member_test for _, member_test in member_scores], axis=0)\n", + "stages[\"+ Context ensemble\"] = metrics(y_test, ensemble_test, DEFAULT_THRESHOLD)\n", + "print(\"Validation AP per member:\", np.round(member_val_ap, 3))\n", + "print(f\"Validation AP of the ensemble: {average_precision_score(y_val, ensemble_val):.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9e6c24f2", + "metadata": {}, + "source": [ + "Ensembling adds little over the best member here; its main benefit is a result that depends less on any single draw of legitimate accounts.\n", + "\n", + "## Strategy 3: tune context and neighbor sampling\n", + "\n", + "Compare single contexts on validation data, keeping each change only if it improves average precision:\n", + "\n", + "* **Recent accounts:** build the context from accounts observed in the last 90 days of the pool, at the same legitimate-to-fraud ratio. Recent examples can better match drifting fraud patterns, but the window holds fewer fraud accounts. Draw both classes from the same window; otherwise the observation date alone can separate them.\n", + "* **Recent transactions:** `temporal_strategy=\"last\"` attaches each account's most recent transactions instead of a uniform sample of its history.\n", + "* **Neighbor count:** try more transactions per account." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b3d2854f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
changerecent_accountsnum_neighborstemporal_strategyvalidation_average_precision
0Current settingsFalse8uniform0.350
1Recent accountsTrue8uniform0.261
2Most recent transactionsFalse8last0.548
316 neighborsFalse16last0.527
432 neighborsFalse32last0.581
\n", + "
" + ], + "text/plain": [ + " change recent_accounts num_neighbors temporal_strategy \\\n", + "0 Current settings False 8 uniform \n", + "1 Recent accounts True 8 uniform \n", + "2 Most recent transactions False 8 last \n", + "3 16 neighbors False 16 last \n", + "4 32 neighbors False 32 last \n", + "\n", + " validation_average_precision \n", + "0 0.350 \n", + "1 0.261 \n", + "2 0.548 \n", + "3 0.527 \n", + "4 0.581 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected sampling settings: {'use_recent': False, 'num_neighbors': 32, 'temporal_strategy': 'last'}\n" + ] + } + ], + "source": [ + "recent_rows = pool_rows[observation_day[pool_rows] >= VALIDATION_START_DAY - RECENT_CONTEXT_DAYS]\n", + "recent_fraud, recent_legit = recent_rows[is_fraud[recent_rows]], recent_rows[~is_fraud[recent_rows]]\n", + "legit_per_fraud = n_legit / n_fraud\n", + "\n", + "\n", + "def candidate_context(use_recent):\n", + " if use_recent:\n", + " return compose_context(recent_fraud, recent_legit, round(legit_per_fraud * len(recent_fraud)), fraud_repeat)\n", + " return compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)\n", + "\n", + "\n", + "trials = []\n", + "\n", + "\n", + "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", + " trial_val, _ = score_evaluation([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", + " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", + " \"temporal_strategy\": temporal_strategy, \"validation_average_precision\": average_precision_score(y_val, trial_val)})\n", + " return trials[-1][\"validation_average_precision\"]\n", + "\n", + "\n", + "settings = {\"use_recent\": False, \"num_neighbors\": 8, \"temporal_strategy\": \"uniform\"}\n", + "best_ap = try_settings(\"Current settings\", **settings)\n", + "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", + " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", + "]:\n", + " trial_ap = try_settings(change, **{**settings, **update})\n", + " if trial_ap > best_ap:\n", + " settings, best_ap = {**settings, **update}, trial_ap\n", + "\n", + "display(pd.DataFrame(trials).round(3))\n", + "print(\"Selected sampling settings:\", settings)" + ] + }, + { + "cell_type": "markdown", + "id": "449b7779", + "metadata": {}, + "source": [ + "A change is kept only when it improves validation average precision, so a setting that helps one portfolio may be rejected for another.\n", + "\n", + "Rebuild the ensemble with the selected settings: the fraud accounts stay fixed while the legitimate accounts vary across members." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9b37fd5b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.0000.0000.0000.5
+ Rebalanced context0.2950.9450.3240.4150.3640.5
+ Context ensemble0.2990.9450.3440.4020.3710.5
+ Sampling settings0.5400.9890.2810.8290.4200.5
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall f1 \\\n", + "Baseline 0.035 0.852 0.000 0.000 0.000 \n", + "+ Rebalanced context 0.295 0.945 0.324 0.415 0.364 \n", + "+ Context ensemble 0.299 0.945 0.344 0.402 0.371 \n", + "+ Sampling settings 0.540 0.989 0.281 0.829 0.420 \n", + "\n", + " threshold \n", + "Baseline 0.5 \n", + "+ Rebalanced context 0.5 \n", + "+ Context ensemble 0.5 \n", + "+ Sampling settings 0.5 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", + "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", + "final_val, final_test = score_evaluation(final_contexts, **sampling_options)\n", + "stages[\"+ Sampling settings\"] = metrics(y_test, final_test, DEFAULT_THRESHOLD)\n", + "display(pd.DataFrame(stages).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "a6037ebc", + "metadata": {}, + "source": [ + "## Strategy 4: tune the decision threshold\n", + "\n", + "The model returns class probabilities, so the cutoff can be chosen outside the model. Sweep thresholds on validation data and choose two operating points: maximum F1, and maximum recall while precision stays at or above `TARGET_PRECISION`. The second suits fraud teams with a fixed review capacity. Apply both to the test accounts." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b59ad480", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max-F1 threshold: 0.614 | Precision-target threshold: 0.685\n" + ] + } + ], + "source": [ + "val_precision, val_recall, candidate_thresholds = precision_recall_curve(y_val, final_val)\n", + "val_precision, val_recall = val_precision[:-1], val_recall[:-1]\n", + "val_f1 = 2 * val_precision * val_recall / np.clip(val_precision + val_recall, 1e-12, None)\n", + "f1_threshold = candidate_thresholds[np.argmax(val_f1)]\n", + "meets_precision = np.flatnonzero(val_precision >= TARGET_PRECISION)\n", + "precision_threshold = candidate_thresholds[meets_precision[np.argmax(val_recall[meets_precision])]] if len(meets_precision) else f1_threshold\n", + "\n", + "stages[\"+ Threshold for max F1\"] = metrics(y_test, final_test, f1_threshold)\n", + "stages[f\"+ Threshold for precision >= {TARGET_PRECISION:.0%}\"] = metrics(y_test, final_test, precision_threshold)\n", + "print(f\"Max-F1 threshold: {f1_threshold:.3f} | Precision-target threshold: {precision_threshold:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0e2f63e9", + "metadata": {}, + "source": [ + "## Compare the lift\n", + "\n", + "Each row adds one strategy to the row above, measured on the same test accounts. Average precision tracks ranking quality; recall and F1 show what the fraud team receives at the chosen cutoff. Values are **demonstration only** and come from synthetic data. A threshold chosen on validation data can land slightly off its precision target on later accounts, so recheck it on fresh labels before adopting it as policy." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8888b467", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.0000.0000.0000.500
+ Rebalanced context0.2950.9450.3240.4150.3640.500
+ Context ensemble0.2990.9450.3440.4020.3710.500
+ Sampling settings0.5400.9890.2810.8290.4200.500
+ Threshold for max F10.5400.9890.3730.7680.5020.614
+ Threshold for precision >= 50%0.5400.9890.4120.6830.5140.685
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall \\\n", + "Baseline 0.035 0.852 0.000 0.000 \n", + "+ Rebalanced context 0.295 0.945 0.324 0.415 \n", + "+ Context ensemble 0.299 0.945 0.344 0.402 \n", + "+ Sampling settings 0.540 0.989 0.281 0.829 \n", + "+ Threshold for max F1 0.540 0.989 0.373 0.768 \n", + "+ Threshold for precision >= 50% 0.540 0.989 0.412 0.683 \n", + "\n", + " f1 threshold \n", + "Baseline 0.000 0.500 \n", + "+ Rebalanced context 0.364 0.500 \n", + "+ Context ensemble 0.371 0.500 \n", + "+ Sampling settings 0.420 0.500 \n", + "+ Threshold for max F1 0.502 0.614 \n", + "+ Threshold for precision >= 50% 0.514 0.685 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average precision: 0.035 -> 0.540; recall: 0.000 -> 0.768; F1: 0.000 -> 0.502\n" + ] + } + ], + "source": [ + "summary = pd.DataFrame(stages).T\n", + "display(summary.round(3))\n", + "baseline_row, final_row = summary.iloc[0], summary.loc[\"+ Threshold for max F1\"]\n", + "print(f\"Average precision: {baseline_row.average_precision:.3f} -> {final_row.average_precision:.3f}; \"\n", + " f\"recall: {baseline_row.recall:.3f} -> {final_row.recall:.3f}; F1: {baseline_row.f1:.3f} -> {final_row.f1:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "96592149", + "metadata": {}, + "source": [ + "Plot the three headline metrics for each stage on separate axes." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "435b00a0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)\n", + "for axis, (column, title) in zip(axes, [(\"average_precision\", \"Average precision\"), (\"recall\", \"Recall\"), (\"f1\", \"F1\")]):\n", + " values = summary[column].to_numpy()[::-1]\n", + " axis.barh(summary.index[::-1], values, color=\"#2a78d6\", height=0.6)\n", + " for position, value in enumerate(values):\n", + " axis.text(value + 0.01, position, f\"{value:.2f}\", va=\"center\", fontsize=9, color=\"#52514e\")\n", + " axis.set_xlim(0, 1)\n", + " axis.set_title(title, loc=\"left\", fontsize=11)\n", + " axis.spines[[\"top\", \"right\"]].set_visible(False)\n", + " axis.grid(axis=\"x\", color=\"#e4e3df\", linewidth=0.8)\n", + " axis.set_axisbelow(True)\n", + "fig.suptitle(\"Test-set lift by strategy (synthetic data, demonstration only)\", x=0.01, ha=\"left\", fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a0246423", + "metadata": {}, + "source": [ + "## Batch predictions\n", + "\n", + "Append the reserved accounts and their transactions to copies of the original tables, then rebuild the relational data and sampler. New accounts have no labels and never enter the context." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a98c162d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accounts to score: 2,000; context accounts per member: 5,943\n" + ] + } + ], + "source": [ + "scoring_accounts = pd.concat([accounts, new_accounts], ignore_index=True)\n", + "scoring_transactions = pd.concat([transactions, new_transactions], ignore_index=True)\n", + "assert set(new_accounts.account_id).isdisjoint(accounts.account_id)\n", + "assert set(new_transactions.transaction_id).isdisjoint(transactions.transaction_id)\n", + "scoring_sampler = build_relational_data(scoring_accounts, scoring_transactions).sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "scoring_query = sdm.TableTensor.from_pandas(\n", + " pd.DataFrame({\"account_id\": new_accounts.account_id, \"timestamp\": scoring_anchors}),\n", + " stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\"},\n", + ")\n", + "print(f\"Accounts to score: {len(new_accounts):,}; context accounts per member: {len(final_contexts[0]):,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6038aa3e", + "metadata": {}, + "source": [ + "Score the new accounts with the final ensemble and sampling settings." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7e3a8d27", + "metadata": {}, + "outputs": [], + "source": [ + "batch_probability = score_contexts(final_contexts, scoring_query, scoring_sampler, **sampling_options)" + ] + }, + { + "cell_type": "markdown", + "id": "995bdb57", + "metadata": {}, + "source": [ + "### Inspect and save the scores\n", + "\n", + "Expect one row per new account in input order. `fraud_probability` is the ensemble's average probability; `review_flag` applies the precision-target threshold chosen on validation data. The flag is illustrative, not a business policy." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "08724d72", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
account_idfraud_probabilityreview_flag
1660816600.967997True
1802818020.947694True
1532815320.932520True
1805818050.925285True
623806230.924746True
\n", + "
" + ], + "text/plain": [ + " account_id fraud_probability review_flag\n", + "1660 81660 0.967997 True\n", + "1802 81802 0.947694 True\n", + "1532 81532 0.932520 True\n", + "1805 81805 0.925285 True\n", + "623 80623 0.924746 True" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flagged 28 of 2,000 accounts; saved to /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx/fraud_predictions.parquet\n" + ] + } + ], + "source": [ + "predictions = pd.DataFrame({\n", + " \"account_id\": new_accounts.account_id.to_numpy(),\n", + " \"fraud_probability\": batch_probability,\n", + " \"review_flag\": batch_probability >= precision_threshold,\n", + "})\n", + "assert len(predictions) == len(new_accounts) and predictions.account_id.is_unique\n", + "assert np.isfinite(predictions.fraud_probability).all() and predictions.fraud_probability.between(0, 1).all()\n", + "prediction_path = run_dir / \"fraud_predictions.parquet\"\n", + "predictions.to_parquet(prediction_path, index=False)\n", + "display(predictions.sort_values(\"fraud_probability\", ascending=False).head())\n", + "print(f\"Flagged {predictions.review_flag.sum()} of {len(predictions):,} accounts; saved to {prediction_path}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7fef0951", + "metadata": {}, + "source": [ + "## Retain the context\n", + "\n", + "KumoRelational has no trained weights to save; the context and settings define the model. Save the context account IDs, sampling settings and thresholds, then reload them to confirm they rebuild the same contexts." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a64b8fad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Context configuration saved and reloaded from /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx/context_config.json\n" + ] + } + ], + "source": [ + "context_config = {\n", + " \"context_account_ids\": [labels.account_id.to_numpy()[rows].tolist() for rows in final_contexts],\n", + " \"sampling_options\": sampling_options,\n", + " \"thresholds\": {\"max_f1\": float(f1_threshold), \"precision_target\": float(precision_threshold)},\n", + "}\n", + "config_path = run_dir / \"context_config.json\"\n", + "config_path.write_text(json.dumps(context_config))\n", + "\n", + "reloaded = json.loads(config_path.read_text())\n", + "row_by_account = pd.Series(np.arange(len(labels)), index=labels.account_id)\n", + "reloaded_contexts = [row_by_account.loc[ids].to_numpy() for ids in reloaded[\"context_account_ids\"]]\n", + "assert all(np.array_equal(a, b) for a, b in zip(reloaded_contexts, final_contexts))\n", + "print(\"Context configuration saved and reloaded from\", config_path)" + ] + }, + { + "cell_type": "markdown", + "id": "956129ec", + "metadata": {}, + "source": [ + "## Keep or remove this run's files\n", + "\n", + "The output directory is kept by default. Set `CLEANUP = True` to remove only the directory created by this run; the cached model checkpoint stays available." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c6d1ac4b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx.\n" + ] + } + ], + "source": [ + "if CLEANUP:\n", + " workspace.cleanup()\n", + "print(\"Removed this run's files.\" if CLEANUP else f\"Results retained in {run_dir}.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From e81b36d3651f3f482df0e4f45fc0778ba82af9bf Mon Sep 17 00:00:00 2001 From: aliu65803 Date: Wed, 18 Nov 2026 17:59:26 -0600 Subject: [PATCH 2/5] Generalize imbalanced-data notebook and use a five-table graph Reframe the example as improving KumoRelational on imbalanced data with fraud as the worked example, move it to cross-industry, model customers, accounts, transactions, merchants and devices with two-hop sampling, and tune a decision threshold for each configuration. Co-Authored-By: Claude Opus 5.5 --- .../structured-data-models/README.md | 13 +- ...els_imbalanced_classification_tuning.ipynb | 1507 ++++++++++++++++ ...odels_fraud_detection_context_tuning.ipynb | 1509 ----------------- 3 files changed, 1519 insertions(+), 1510 deletions(-) create mode 100644 examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb delete mode 100644 examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb diff --git a/examples/kumo-example-notebooks/structured-data-models/README.md b/examples/kumo-example-notebooks/structured-data-models/README.md index 965770960..228f4169e 100644 --- a/examples/kumo-example-notebooks/structured-data-models/README.md +++ b/examples/kumo-example-notebooks/structured-data-models/README.md @@ -14,6 +14,12 @@ Client examples require an existing endpoint; they do not provision one. ### Cross-industry +#### Notebooks + +| Example | Deployment | Scope | +| --- | --- | --- | +| [Improve KumoRelational performance on imbalanced data, with a fraud example](relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb) | Local | Model workflow | + #### SDK code examples | Example | Deployment | Scope | @@ -27,7 +33,6 @@ Client examples require an existing endpoint; they do not provision one. | Example | Deployment | Scope | | --- | --- | --- | | [Screen synthetic accounts with client KumoRelational](relational/fsi/notebooks/local_structured_data_models_client_money_muling_detection.ipynb) | Local | Model workflow | -| [Improve fraud recall on imbalanced accounts by tuning context, sampling and threshold](relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb) | Local | Model workflow | ### Retail @@ -163,6 +168,12 @@ Client examples require an existing endpoint; they do not provision one. ### Cross-industry +#### Notebooks + +| Example | Deployment | Scope | +| --- | --- | --- | +| [Improve KumoRelational performance on imbalanced data, with a fraud example](relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb) | Local | Model workflow | + #### SDK code examples | Example | Deployment | Scope | diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb new file mode 100644 index 000000000..7dcbde703 --- /dev/null +++ b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb @@ -0,0 +1,1507 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "24b42002", + "metadata": {}, + "source": [ + "# Improve KumoRelational performance on imbalanced data\n", + "\n", + "KumoRelational, a relational foundation model (RFM), predicts from labeled in-context examples. With a rare positive class, a random context holds few positives and the model under-predicts that class at the default 0.5 cutoff. This notebook tests four fixes and measures the lift of each, using fraud detection as the example: which accounts will be confirmed as fraud within 30 days?\n", + "\n", + "| Strategy | What changes |\n", + "| --- | --- |\n", + "| 1. Rebalance the context | Include all positives; test class ratios, context size and positive repetition. |\n", + "| 2. Ensemble contexts | Keep the positives fixed, vary the negatives, average the predictions. |\n", + "| 3. Tune sampling | Recent entities, most recent neighbors, neighbor count. |\n", + "| 4. Tune the threshold | Pick a cutoff on validation data for each configuration. |\n", + "\n", + "Runs locally with Python 3.12+ and [direct KumoRelational](https://nvidia.github.io/structured-data-models/api/generated/sdm.models.KumoRelational.html), in about 20 minutes on CPU. Data is synthetic; metrics are **demonstration only**." + ] + }, + { + "cell_type": "markdown", + "id": "b89d6820", + "metadata": {}, + "source": [ + "## Install and configure\n", + "\n", + "On CPU, sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ceb339d5", + "metadata": {}, + "outputs": [], + "source": [ + "%pip install structured-data-models pandas pyarrow scikit-learn matplotlib graphviz" + ] + }, + { + "cell_type": "markdown", + "id": "d0325b98", + "metadata": {}, + "source": [ + "## Set the parameters\n", + "\n", + "Accounts are split by observation date into a context pool, a validation window for choosing settings and thresholds, and a test window for reporting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "36dfda2d", + "metadata": {}, + "outputs": [], + "source": [ + "SEED = 7\n", + "N_ACCOUNTS = 80_000\n", + "FRAUD_RATE = 0.005\n", + "START = \"2026-01-01\"\n", + "HISTORY_DAYS = 90\n", + "VALIDATION_START_DAY = 270\n", + "TEST_START_DAY = 310\n", + "\n", + "BASELINE_CONTEXT_SIZE = 5_000\n", + "LARGE_CONTEXT_SIZE = 10_000\n", + "FRAUD_REPEAT = 10\n", + "NUM_ESTIMATORS = 5\n", + "RECENT_CONTEXT_DAYS = 90\n", + "FIRST_HOP_NEIGHBORS = 8\n", + "SECOND_HOP_NEIGHBORS = 4\n", + "NEIGHBOR_OPTIONS = [16]\n", + "\n", + "DEFAULT_THRESHOLD = 0.5\n", + "TARGET_PRECISION = 0.5\n", + "OUTPUT_PARENT = None\n", + "CLEANUP = False" + ] + }, + { + "cell_type": "markdown", + "id": "55344016", + "metadata": {}, + "source": [ + "Import the libraries and create an output directory for this run." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8a4739ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-fqxhuh07\n" + ] + } + ], + "source": [ + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import sdm\n", + "import torch\n", + "from IPython.display import display\n", + "from sklearn.metrics import average_precision_score, f1_score, precision_recall_curve, precision_score, recall_score, roc_auc_score\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "rng = np.random.default_rng(SEED)\n", + "workspace = tempfile.TemporaryDirectory(prefix=\"fraud-context-tuning-\", dir=OUTPUT_PARENT, delete=False)\n", + "run_dir = Path(workspace.name)\n", + "print(\"Device:\", device, \"| Results:\", run_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "f1986d35", + "metadata": {}, + "source": [ + "## Generate synthetic example data\n", + "\n", + "Run the next cell to create five tables: customers, accounts, transactions, merchants and devices. You can skim it; the workflow starts at **Build the relational data**.\n", + "\n", + "Fraud accounts tend to show a burst of activity just before their observation date, often at high-risk merchants or on shared or emulated devices, and belong to newer customers. Some legitimate accounts look similar, and the fraud pattern drifts mid-year." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "678a7276", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
rows
customers60000
accounts80000
transactions2257154
merchants2000
devices61500
\n", + "
" + ], + "text/plain": [ + " rows\n", + "customers 60000\n", + "accounts 80000\n", + "transactions 2257154\n", + "merchants 2000\n", + "devices 61500" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraud rate: 0.52% (about 1 in 193)\n" + ] + } + ], + "source": [ + "N_CUSTOMERS = int(N_ACCOUNTS * 0.75)\n", + "N_MERCHANTS = 2_000\n", + "N_SHARED_DEVICES = 1_500\n", + "DRIFT_DAY = 215\n", + "\n", + "merchants = pd.DataFrame({\n", + " \"merchant_id\": np.arange(N_MERCHANTS),\n", + " \"risk_score\": rng.beta(1.5, 12, N_MERCHANTS).round(3),\n", + " \"is_online\": (rng.random(N_MERCHANTS) < 0.4).astype(float),\n", + " \"avg_ticket\": rng.lognormal(3.6, 0.6, N_MERCHANTS).round(2),\n", + "})\n", + "risky_merchants = {\n", + " \"early\": merchants.merchant_id[(merchants.risk_score > merchants.risk_score.quantile(0.9)) & (merchants.is_online == 0)].to_numpy(),\n", + " \"late\": merchants.merchant_id[(merchants.risk_score > merchants.risk_score.quantile(0.9)) & (merchants.is_online == 1)].to_numpy(),\n", + "}\n", + "everyday_merchants = merchants.merchant_id[merchants.risk_score <= merchants.risk_score.quantile(0.9)].to_numpy()\n", + "\n", + "customers = pd.DataFrame({\n", + " \"customer_id\": np.arange(N_CUSTOMERS),\n", + " \"customer_age_years\": rng.integers(18, 85, N_CUSTOMERS).astype(float),\n", + " \"tenure_days\": rng.gamma(3.0, 400, N_CUSTOMERS).round(),\n", + " \"kyc_tier\": rng.integers(1, 4, N_CUSTOMERS).astype(float),\n", + "})\n", + "devices = pd.DataFrame({\n", + " \"device_id\": np.arange(N_CUSTOMERS + N_SHARED_DEVICES),\n", + " \"is_emulator\": np.r_[np.zeros(N_CUSTOMERS), (rng.random(N_SHARED_DEVICES) < 0.7)].astype(float),\n", + " \"device_age_days\": np.r_[rng.gamma(3.0, 200, N_CUSTOMERS), rng.gamma(1.0, 15, N_SHARED_DEVICES)].round(),\n", + "})\n", + "recent_customers = customers.customer_id[customers.tenure_days < 180].to_numpy()\n", + "shared_devices = np.arange(N_CUSTOMERS, N_CUSTOMERS + N_SHARED_DEVICES)\n", + "\n", + "\n", + "def simulate_transactions(owners, anchors, owner_devices, window_days, pattern):\n", + " n = len(owners)\n", + " if pattern == \"everyday\":\n", + " amount, intl, hour, merchant = rng.lognormal(3.5, 0.9, n), rng.random(n) < 0.05, rng.normal(14, 4, n), rng.choice(everyday_merchants, n)\n", + " device = np.where(rng.random(n) < 0.02, rng.choice(shared_devices, n), owner_devices)\n", + " elif pattern == \"lookalike\":\n", + " amount = np.where(rng.random(n) < 0.5, rng.lognormal(3.0, 0.6, n), rng.lognormal(5.8, 0.6, n))\n", + " intl, hour = rng.random(n) < 0.5, np.where(rng.random(n) < 0.5, rng.normal(2, 2, n), rng.normal(14, 4, n))\n", + " merchant = np.where(rng.random(n) < 0.3, rng.choice(np.r_[risky_merchants[\"early\"], risky_merchants[\"late\"]], n), rng.choice(everyday_merchants, n))\n", + " device = np.where(rng.random(n) < 0.25, rng.choice(shared_devices, n), owner_devices)\n", + " else:\n", + " late = pattern == \"late\"\n", + " amount = rng.lognormal(3.0, 0.6, n) if late else rng.lognormal(6.0, 0.6, n)\n", + " intl, hour = rng.random(n) < (0.6 if late else 0.15), rng.normal(2, 2, n) if late else rng.normal(14, 4, n)\n", + " merchant = np.where(rng.random(n) < 0.35, rng.choice(risky_merchants[pattern], n), rng.choice(everyday_merchants, n))\n", + " device = np.where(rng.random(n) < (0.35 if late else 0.1), rng.choice(shared_devices, n), owner_devices)\n", + " return pd.DataFrame({\n", + " \"account_id\": owners, \"merchant_id\": merchant, \"device_id\": device,\n", + " \"timestamp\": anchors - pd.to_timedelta(rng.uniform(0, window_days, n), unit=\"D\"),\n", + " \"amount\": amount.round(2), \"is_international\": intl.astype(float), \"hour_of_day\": hour.clip(0, 23).round(),\n", + " })\n", + "\n", + "\n", + "def simulate_accounts(account_ids, anchors):\n", + " n = len(account_ids)\n", + " is_fraud = rng.random(n) < FRAUD_RATE\n", + " owner = np.where(is_fraud & (rng.random(n) < 0.4), rng.choice(recent_customers, n), rng.integers(0, N_CUSTOMERS, n))\n", + " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", + " account_frame = pd.DataFrame({\n", + " \"account_id\": account_ids, \"customer_id\": owner,\n", + " \"account_age_days\": np.where(is_fraud, rng.gamma(2.0, 150, n), rng.gamma(3.0, 300, n)).round(),\n", + " \"credit_limit\": rng.lognormal(8.0, 0.6, n).round(-2),\n", + " })\n", + " counts = rng.poisson(24, n) + 4\n", + " parts = [simulate_transactions(np.repeat(account_ids, counts), np.repeat(anchors.values, counts), np.repeat(owner, counts), HISTORY_DAYS, \"everyday\")]\n", + " bursty_fraud = is_fraud & (rng.random(n) < 0.8)\n", + " lookalikes = ~is_fraud & (rng.random(n) < 0.04)\n", + " for selected, mean_count, pattern in (\n", + " (bursty_fraud & ~late, 4, \"early\"), (bursty_fraud & late, 4, \"late\"), (lookalikes, 4, \"lookalike\"),\n", + " ):\n", + " k = rng.poisson(mean_count, selected.sum()) + 1\n", + " parts.append(simulate_transactions(\n", + " np.repeat(account_ids[selected], k), np.repeat(anchors.values[selected], k), np.repeat(owner[selected], k), 5, pattern\n", + " ))\n", + " transaction_frame = pd.concat(parts, ignore_index=True).sort_values(\"timestamp\", ignore_index=True)\n", + " transaction_frame[\"timestamp\"] = transaction_frame.timestamp.dt.floor(\"s\")\n", + " label_frame = pd.DataFrame({\"account_id\": account_ids, \"timestamp\": anchors, \"is_fraud\": np.where(is_fraud, \"fraud\", \"legit\")})\n", + " return account_frame, transaction_frame, label_frame\n", + "\n", + "\n", + "history_anchors = pd.Timestamp(START) + pd.to_timedelta(rng.integers(60, 365, N_ACCOUNTS), unit=\"D\")\n", + "accounts, transactions, labels = simulate_accounts(np.arange(N_ACCOUNTS), history_anchors)\n", + "transactions.insert(0, \"transaction_id\", np.arange(len(transactions)))\n", + "\n", + "display(pd.Series({\"customers\": len(customers), \"accounts\": len(accounts), \"transactions\": len(transactions),\n", + " \"merchants\": len(merchants), \"devices\": len(devices)}, name=\"rows\").to_frame())\n", + "print(f\"Fraud rate: {labels.is_fraud.eq('fraud').mean():.2%} (about 1 in {round(1 / labels.is_fraud.eq('fraud').mean())})\")" + ] + }, + { + "cell_type": "markdown", + "id": "7b99e336", + "metadata": {}, + "source": [ + "## Build the relational data\n", + "\n", + "Declare column types and foreign keys. KumoRelational uses numerical and datetime features, and the sampler only uses transactions before each account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fb9900ab", + "metadata": {}, + "outputs": [], + "source": [ + "STYPES = {\n", + " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"tenure_days\": \"numerical\", \"kyc_tier\": \"numerical\"},\n", + " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"account_age_days\": \"numerical\", \"credit_limit\": \"numerical\"},\n", + " \"merchants\": {\"merchant_id\": \"id\", \"risk_score\": \"numerical\", \"is_online\": \"numerical\", \"avg_ticket\": \"numerical\"},\n", + " \"devices\": {\"device_id\": \"id\", \"is_emulator\": \"numerical\", \"device_age_days\": \"numerical\"},\n", + " \"transactions\": {\n", + " \"transaction_id\": \"id\", \"account_id\": \"id\", \"merchant_id\": \"id\", \"device_id\": \"id\", \"timestamp\": \"datetime\",\n", + " \"amount\": \"numerical\", \"is_international\": \"numerical\", \"hour_of_day\": \"numerical\",\n", + " },\n", + "}\n", + "RELATIONSHIPS = [\n", + " {\"left_table\": \"accounts\", \"left_column\": \"customer_id\", \"right_table\": \"customers\", \"right_column\": \"customer_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"account_id\", \"right_table\": \"accounts\", \"right_column\": \"account_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"merchant_id\", \"right_table\": \"merchants\", \"right_column\": \"merchant_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"device_id\", \"right_table\": \"devices\", \"right_column\": \"device_id\"},\n", + "]\n", + "TASK_LINK = {\"task_column\": \"account_id\", \"table\": \"accounts\", \"table_column\": \"account_id\"}\n", + "\n", + "frames = {\"customers\": customers, \"accounts\": accounts, \"merchants\": merchants, \"devices\": devices, \"transactions\": transactions}\n", + "data = sdm.RelationalData(\n", + " tables={name: sdm.TableTensor.from_pandas(frame, stypes=STYPES[name]) for name, frame in frames.items()},\n", + " relationships=RELATIONSHIPS,\n", + ")\n", + "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"is_fraud\": \"categorical\"})" + ] + }, + { + "cell_type": "markdown", + "id": "792e0cb6", + "metadata": {}, + "source": [ + "Merchant and device risk sit two hops from an account, through its transactions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2b4b84bf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "customers\n", + "\n", + "customers\n", + "\n", + "customer_id: id\n", + "customer_age_years: numerical\n", + "tenure_days: numerical\n", + "kyc_tier: numerical\n", + "\n", + "\n", + "\n", + "accounts\n", + "\n", + "accounts\n", + "\n", + "account_id: id\n", + "customer_id: id\n", + "account_age_days: numerical\n", + "credit_limit: numerical\n", + "\n", + "\n", + "\n", + "accounts--customers\n", + "\n", + " customer_id <> customer_id \n", + "\n", + "\n", + "\n", + "merchants\n", + "\n", + "merchants\n", + "\n", + "merchant_id: id\n", + "risk_score: numerical\n", + "is_online: numerical\n", + "avg_ticket: numerical\n", + "\n", + "\n", + "\n", + "devices\n", + "\n", + "devices\n", + "\n", + "device_id: id\n", + "is_emulator: numerical\n", + "device_age_days: numerical\n", + "\n", + "\n", + "\n", + "transactions\n", + "\n", + "transactions\n", + "\n", + "transaction_id: id\n", + "account_id: id\n", + "merchant_id: id\n", + "device_id: id\n", + "timestamp: datetime\n", + "amount: numerical\n", + "is_international: numerical\n", + "hour_of_day: numerical\n", + "\n", + "\n", + "\n", + "transactions--accounts\n", + "\n", + " account_id <> account_id \n", + "\n", + "\n", + "\n", + "transactions--merchants\n", + "\n", + " merchant_id <> merchant_id \n", + "\n", + "\n", + "\n", + "transactions--devices\n", + "\n", + " device_id <> device_id \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.to_graphviz()" + ] + }, + { + "cell_type": "markdown", + "id": "dbea97e7", + "metadata": {}, + "source": [ + "## Split accounts by time\n", + "\n", + "Context pool: before day 270. Validation: days 270 to 309. Test: day 310 onward." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "483b06b2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accountsfraud_accounts
context pool55219294
validation1046454
test1431766
\n", + "
" + ], + "text/plain": [ + " accounts fraud_accounts\n", + "context pool 55219 294\n", + "validation 10464 54\n", + "test 14317 66" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", + "is_fraud = labels.is_fraud.eq(\"fraud\").to_numpy()\n", + "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", + "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", + "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", + "fraud_pool = pool_rows[is_fraud[pool_rows]]\n", + "legit_pool = pool_rows[~is_fraud[pool_rows]]\n", + "y_val, y_test = is_fraud[val_rows], is_fraud[test_rows]\n", + "\n", + "display(pd.DataFrame({\n", + " \"accounts\": [len(pool_rows), len(val_rows), len(test_rows)],\n", + " \"fraud_accounts\": [is_fraud[pool_rows].sum(), y_val.sum(), y_test.sum()],\n", + "}, index=[\"context pool\", \"validation\", \"test\"]))" + ] + }, + { + "cell_type": "markdown", + "id": "d34604c0", + "metadata": {}, + "source": [ + "## Define the helpers\n", + "\n", + "`score_contexts` fits the model on each context, scores the queries and averages the probabilities; one context is an ensemble of one. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "34c71ffd", + "metadata": {}, + "outputs": [], + "source": [ + "model = sdm.models.KumoRelational(device=device)\n", + "evaluation_query = task_table[torch.as_tensor(np.concatenate([val_rows, test_rows]))].drop_columns(\"is_fraud\")\n", + "\n", + "\n", + "def score_contexts(contexts, query, relational_sampler, num_neighbors=FIRST_HOP_NEIGHBORS, temporal_strategy=\"uniform\", batch_size=10_000):\n", + " options = dict(task_link=TASK_LINK, num_neighbors=[num_neighbors, SECOND_HOP_NEIGHBORS], task_time_column=\"timestamp\", temporal_strategy=temporal_strategy)\n", + " member_probabilities = []\n", + " for context_rows in contexts:\n", + " torch.manual_seed(SEED)\n", + " context, related = relational_sampler(task_table[torch.as_tensor(context_rows)], **options).to(device)\n", + " model.fit(x=context.drop_columns(\"is_fraud\"), y=context[\"is_fraud\"], related_tables=related)\n", + " batches = []\n", + " for query_batch in query.split(batch_size, -2):\n", + " out = model.predict(*relational_sampler(query_batch, **options).to(device))\n", + " batches.append(out.numerical[:, list(out.columns[sdm.Stype.numerical]).index(\"fraud\")].float().cpu().numpy())\n", + " member_probabilities.append(np.concatenate(batches))\n", + " return np.mean(member_probabilities, axis=0)\n", + "\n", + "\n", + "def score_evaluation(contexts, **options):\n", + " probabilities = score_contexts(contexts, evaluation_query, sampler, **options)\n", + " return probabilities[: len(val_rows)], probabilities[len(val_rows):]\n", + "\n", + "\n", + "def metrics(y_true, probability, threshold):\n", + " flagged = probability >= threshold\n", + " return {\n", + " \"average_precision\": average_precision_score(y_true, probability),\n", + " \"auroc\": roc_auc_score(y_true, probability),\n", + " \"precision\": precision_score(y_true, flagged, zero_division=0),\n", + " \"recall\": recall_score(y_true, flagged),\n", + " \"f1\": f1_score(y_true, flagged),\n", + " \"threshold\": threshold,\n", + " }\n", + "\n", + "\n", + "def max_f1_threshold(y_true, probability):\n", + " precision, recall, thresholds = precision_recall_curve(y_true, probability)\n", + " f1 = 2 * precision[:-1] * recall[:-1] / np.clip(precision[:-1] + recall[:-1], 1e-12, None)\n", + " return thresholds[np.argmax(f1)]\n", + "\n", + "\n", + "def compose_context(fraud_rows, legit_rows, n_legit, fraud_repeat=1):\n", + " return np.concatenate([np.tile(fraud_rows, fraud_repeat), rng.choice(legit_rows, n_legit, replace=False)])\n", + "\n", + "\n", + "stages = {}" + ] + }, + { + "cell_type": "markdown", + "id": "82f4fd9a", + "metadata": {}, + "source": [ + "## Score the baseline\n", + "\n", + "Use a random context at the natural fraud rate and the default 0.5 cutoff." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4a25a0a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraud examples in the baseline context: 22 of 5000\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Baseline0.2870.9380.7140.0760.1370.5
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall f1 threshold\n", + "Baseline 0.287 0.938 0.714 0.076 0.137 0.5" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "baseline_context = rng.choice(pool_rows, BASELINE_CONTEXT_SIZE, replace=False)\n", + "baseline_val, baseline_test = score_evaluation([baseline_context])\n", + "stages[\"Baseline\"] = (baseline_val, baseline_test)\n", + "print(f\"Fraud examples in the baseline context: {is_fraud[baseline_context].sum()} of {BASELINE_CONTEXT_SIZE}\")\n", + "display(pd.DataFrame({\"Baseline\": metrics(y_test, baseline_test, DEFAULT_THRESHOLD)}).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "53437807", + "metadata": {}, + "source": [ + "With few positives in context, the model is conservative: reasonable precision, low recall.\n", + "\n", + "## Strategy 1: rebalance the context\n", + "\n", + "Every candidate contains all fraud accounts in the pool: ratios of 1:1, 1:5 and 1:20, a 10,000-row context, and a 10,000-row context with each fraud account repeated 10 times. Select by validation average precision, which is threshold-free." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bfe64ce3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
validation_average_precisionvalidation_recall_at_0.5validation_precision_at_0.5
1:10.2760.9630.018
1:50.2540.7040.063
1:200.3020.4070.265
All fraud, 10,000 rows0.3290.4630.238
Fraud x10, 10,000 rows0.3410.5370.121
\n", + "
" + ], + "text/plain": [ + " validation_average_precision \\\n", + "1:1 0.276 \n", + "1:5 0.254 \n", + "1:20 0.302 \n", + "All fraud, 10,000 rows 0.329 \n", + "Fraud x10, 10,000 rows 0.341 \n", + "\n", + " validation_recall_at_0.5 validation_precision_at_0.5 \n", + "1:1 0.963 0.018 \n", + "1:5 0.704 0.063 \n", + "1:20 0.407 0.265 \n", + "All fraud, 10,000 rows 0.463 0.238 \n", + "Fraud x10, 10,000 rows 0.537 0.121 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected context design: Fraud x10, 10,000 rows\n" + ] + } + ], + "source": [ + "n_fraud = len(fraud_pool)\n", + "context_designs = {\n", + " \"1:1\": (1, n_fraud),\n", + " \"1:5\": (1, 5 * n_fraud),\n", + " \"1:20\": (1, 20 * n_fraud),\n", + " f\"All fraud, {LARGE_CONTEXT_SIZE:,} rows\": (1, LARGE_CONTEXT_SIZE - n_fraud),\n", + " f\"Fraud x{FRAUD_REPEAT}, {LARGE_CONTEXT_SIZE:,} rows\": (FRAUD_REPEAT, LARGE_CONTEXT_SIZE - FRAUD_REPEAT * n_fraud),\n", + "}\n", + "design_scores = {}\n", + "for name, (fraud_repeat, n_legit) in context_designs.items():\n", + " design_val, design_test = score_evaluation([compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)])\n", + " design_scores[name] = (design_val, design_test)\n", + "\n", + "comparison = pd.DataFrame({\n", + " name: {\n", + " \"validation_average_precision\": average_precision_score(y_val, design_val),\n", + " \"validation_recall_at_0.5\": recall_score(y_val, design_val >= DEFAULT_THRESHOLD),\n", + " \"validation_precision_at_0.5\": precision_score(y_val, design_val >= DEFAULT_THRESHOLD, zero_division=0),\n", + " }\n", + " for name, (design_val, _) in design_scores.items()\n", + "}).T\n", + "best_design = comparison.validation_average_precision.idxmax()\n", + "fraud_repeat, n_legit = context_designs[best_design]\n", + "stages[\"+ Rebalanced context\"] = design_scores[best_design]\n", + "display(comparison.round(3))\n", + "print(\"Selected context design:\", best_design)" + ] + }, + { + "cell_type": "markdown", + "id": "b041663c", + "metadata": {}, + "source": [ + "Fewer negatives per positive also raise the probabilities, which moves precision and recall at 0.5; strategy 4 handles this.\n", + "\n", + "## Strategy 2: ensemble contexts\n", + "\n", + "Use the same fraud accounts in every context with a different draw of negatives, then average the members. See [ensembling](https://nvidia.github.io/structured-data-models/icl.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c99df08e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation AP per member: [0.338 0.335 0.321 0.349 0.312]\n", + "Validation AP of the ensemble: 0.347\n" + ] + } + ], + "source": [ + "ensemble_contexts = [compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat) for _ in range(NUM_ESTIMATORS)]\n", + "member_scores = [score_evaluation([context]) for context in ensemble_contexts]\n", + "member_val_ap = [average_precision_score(y_val, member_val) for member_val, _ in member_scores]\n", + "ensemble_val = np.mean([member_val for member_val, _ in member_scores], axis=0)\n", + "ensemble_test = np.mean([member_test for _, member_test in member_scores], axis=0)\n", + "stages[\"+ Context ensemble\"] = (ensemble_val, ensemble_test)\n", + "print(\"Validation AP per member:\", np.round(member_val_ap, 3))\n", + "print(f\"Validation AP of the ensemble: {average_precision_score(y_val, ensemble_val):.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "32cfafa0", + "metadata": {}, + "source": [ + "The ensemble mainly reduces variance from the negative draw; it beats the average member, but not always the best one.\n", + "\n", + "## Strategy 3: tune sampling\n", + "\n", + "Test each change on a single context and keep it only if validation average precision improves:\n", + "\n", + "* **Recent accounts:** build the context from the pool's last 90 days at the same class ratio. Draw both classes from that window, or the observation date leaks the label.\n", + "* **Most recent transactions:** `temporal_strategy=\"last\"` instead of a uniform sample.\n", + "* **More neighbors:** more first-hop transactions per account." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "46692a91", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
changerecent_accountsnum_neighborstemporal_strategyvalidation_average_precision
0Current settingsFalse8uniform0.384
1Recent accountsTrue8uniform0.213
2Most recent transactionsFalse8last0.469
316 neighborsFalse16last0.312
\n", + "
" + ], + "text/plain": [ + " change recent_accounts num_neighbors temporal_strategy \\\n", + "0 Current settings False 8 uniform \n", + "1 Recent accounts True 8 uniform \n", + "2 Most recent transactions False 8 last \n", + "3 16 neighbors False 16 last \n", + "\n", + " validation_average_precision \n", + "0 0.384 \n", + "1 0.213 \n", + "2 0.469 \n", + "3 0.312 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected sampling settings: {'use_recent': False, 'num_neighbors': 8, 'temporal_strategy': 'last'}\n" + ] + } + ], + "source": [ + "recent_rows = pool_rows[observation_day[pool_rows] >= VALIDATION_START_DAY - RECENT_CONTEXT_DAYS]\n", + "recent_fraud, recent_legit = recent_rows[is_fraud[recent_rows]], recent_rows[~is_fraud[recent_rows]]\n", + "legit_per_fraud = n_legit / n_fraud\n", + "\n", + "\n", + "def candidate_context(use_recent):\n", + " if use_recent:\n", + " return compose_context(recent_fraud, recent_legit, round(legit_per_fraud * len(recent_fraud)), fraud_repeat)\n", + " return compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)\n", + "\n", + "\n", + "trials = []\n", + "\n", + "\n", + "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", + " trial_val, _ = score_evaluation([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", + " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", + " \"temporal_strategy\": temporal_strategy, \"validation_average_precision\": average_precision_score(y_val, trial_val)})\n", + " return trials[-1][\"validation_average_precision\"]\n", + "\n", + "\n", + "settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", + "best_ap = try_settings(\"Current settings\", **settings)\n", + "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", + " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", + "]:\n", + " trial_ap = try_settings(change, **{**settings, **update})\n", + " if trial_ap > best_ap:\n", + " settings, best_ap = {**settings, **update}, trial_ap\n", + "\n", + "display(pd.DataFrame(trials).round(3))\n", + "print(\"Selected sampling settings:\", settings)" + ] + }, + { + "cell_type": "markdown", + "id": "1a9c6baa", + "metadata": {}, + "source": [ + "Rebuild the ensemble with the selected settings." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "afe53b51", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
validation_average_precisionvalidation_recall_at_0.5
Baseline0.2910.167
+ Rebalanced context0.3410.537
+ Context ensemble0.3470.593
+ Sampling settings0.5990.111
\n", + "
" + ], + "text/plain": [ + " validation_average_precision validation_recall_at_0.5\n", + "Baseline 0.291 0.167\n", + "+ Rebalanced context 0.341 0.537\n", + "+ Context ensemble 0.347 0.593\n", + "+ Sampling settings 0.599 0.111" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", + "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", + "final_val, final_test = score_evaluation(final_contexts, **sampling_options)\n", + "stages[\"+ Sampling settings\"] = (final_val, final_test)\n", + "display(pd.DataFrame({\n", + " \"validation_average_precision\": {name: average_precision_score(y_val, val_prob) for name, (val_prob, _) in stages.items()},\n", + " \"validation_recall_at_0.5\": {name: recall_score(y_val, val_prob >= DEFAULT_THRESHOLD) for name, (val_prob, _) in stages.items()},\n", + "}).round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "6c02d0de", + "metadata": {}, + "source": [ + "Recall at 0.5 can swing here, even to zero, because these settings also change the probability scale. For example, repeated positives sampled with `\"last\"` become identical copies, which can push every probability down.\n", + "\n", + "## Strategy 4: tune the threshold per configuration\n", + "\n", + "Choose the max-F1 cutoff on validation data for every stage. Re-tune whenever the context or sampling changes." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ebd64c4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
max_f1_threshold
Baseline0.390
+ Rebalanced context0.970
+ Context ensemble0.838
+ Sampling settings0.060
\n", + "
" + ], + "text/plain": [ + " max_f1_threshold\n", + "Baseline 0.390\n", + "+ Rebalanced context 0.970\n", + "+ Context ensemble 0.838\n", + "+ Sampling settings 0.060" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tuned_thresholds = {name: max_f1_threshold(y_val, val_prob) for name, (val_prob, _) in stages.items()}\n", + "display(pd.Series(tuned_thresholds, name=\"max_f1_threshold\").round(3).to_frame())" + ] + }, + { + "cell_type": "markdown", + "id": "46849252", + "metadata": {}, + "source": [ + "The cutoffs vary widely, so one carried over from another configuration can flag far too many or too few accounts.\n", + "\n", + "For fixed review capacity, an alternative is maximum recall at validation precision of at least `TARGET_PRECISION`. Compare both on the final configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "fb8f055e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Max F10.5530.9610.6100.5450.5760.060
Precision >= 50%0.5530.9610.4130.6520.5060.039
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall f1 \\\n", + "Max F1 0.553 0.961 0.610 0.545 0.576 \n", + "Precision >= 50% 0.553 0.961 0.413 0.652 0.506 \n", + "\n", + " threshold \n", + "Max F1 0.060 \n", + "Precision >= 50% 0.039 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "val_precision, val_recall, candidate_thresholds = precision_recall_curve(y_val, final_val)\n", + "meets_precision = np.flatnonzero(val_precision[:-1] >= TARGET_PRECISION)\n", + "precision_threshold = (candidate_thresholds[meets_precision[np.argmax(val_recall[:-1][meets_precision])]]\n", + " if len(meets_precision) else tuned_thresholds[\"+ Sampling settings\"])\n", + "display(pd.DataFrame({\n", + " \"Max F1\": metrics(y_test, final_test, tuned_thresholds[\"+ Sampling settings\"]),\n", + " f\"Precision >= {TARGET_PRECISION:.0%}\": metrics(y_test, final_test, precision_threshold),\n", + "}).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "165e1dfc", + "metadata": {}, + "source": [ + "## Compare the lift\n", + "\n", + "Each row adds one strategy to the row above and, after the first row, uses its own tuned cutoff. All rows use the same test accounts, and the table is saved to the run directory. **Demonstration only.** A validation-tuned cutoff can miss its target on new data, so recheck it before setting policy." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e66b8256", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
average_precisionaurocprecisionrecallf1threshold
Baseline, 0.5 cutoff0.2870.9380.7140.0760.1370.500
Baseline, tuned cutoff0.2870.9380.6250.1520.2440.390
+ Rebalanced context0.3220.9560.6470.1670.2650.970
+ Context ensemble0.3920.9540.4580.4090.4320.838
+ Sampling settings0.5530.9610.6100.5450.5760.060
\n", + "
" + ], + "text/plain": [ + " average_precision auroc precision recall f1 \\\n", + "Baseline, 0.5 cutoff 0.287 0.938 0.714 0.076 0.137 \n", + "Baseline, tuned cutoff 0.287 0.938 0.625 0.152 0.244 \n", + "+ Rebalanced context 0.322 0.956 0.647 0.167 0.265 \n", + "+ Context ensemble 0.392 0.954 0.458 0.409 0.432 \n", + "+ Sampling settings 0.553 0.961 0.610 0.545 0.576 \n", + "\n", + " threshold \n", + "Baseline, 0.5 cutoff 0.500 \n", + "Baseline, tuned cutoff 0.390 \n", + "+ Rebalanced context 0.970 \n", + "+ Context ensemble 0.838 \n", + "+ Sampling settings 0.060 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average precision: 0.287 -> 0.553; recall: 0.076 -> 0.545; F1: 0.137 -> 0.576\n" + ] + } + ], + "source": [ + "lift_rows = {\"Baseline, 0.5 cutoff\": metrics(y_test, baseline_test, DEFAULT_THRESHOLD)}\n", + "for name, (_, test_prob) in stages.items():\n", + " lift_rows[\"Baseline, tuned cutoff\" if name == \"Baseline\" else name] = metrics(y_test, test_prob, tuned_thresholds[name])\n", + "summary = pd.DataFrame(lift_rows).T\n", + "summary.to_csv(run_dir / \"lift_summary.csv\")\n", + "display(summary.round(3))\n", + "baseline_row, final_row = summary.iloc[0], summary.iloc[-1]\n", + "print(f\"Average precision: {baseline_row.average_precision:.3f} -> {final_row.average_precision:.3f}; \"\n", + " f\"recall: {baseline_row.recall:.3f} -> {final_row.recall:.3f}; F1: {baseline_row.f1:.3f} -> {final_row.f1:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c6d1118c", + "metadata": {}, + "source": [ + "Plot the headline metrics by stage." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "86a4c153", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)\n", + "for axis, (column, title) in zip(axes, [(\"average_precision\", \"Average precision\"), (\"recall\", \"Recall\"), (\"f1\", \"F1\")]):\n", + " values = summary[column].to_numpy()[::-1]\n", + " axis.barh(summary.index[::-1], values, color=\"#2a78d6\", height=0.6)\n", + " for position, value in enumerate(values):\n", + " axis.text(value + 0.01, position, f\"{value:.2f}\", va=\"center\", fontsize=9, color=\"#52514e\")\n", + " axis.set_xlim(0, 1)\n", + " axis.set_title(title, loc=\"left\", fontsize=11)\n", + " axis.spines[[\"top\", \"right\"]].set_visible(False)\n", + " axis.grid(axis=\"x\", color=\"#e4e3df\", linewidth=0.8)\n", + " axis.set_axisbelow(True)\n", + "fig.suptitle(\"Test-set lift by strategy (synthetic data, demonstration only)\", x=0.01, ha=\"left\", fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f25e8b86", + "metadata": {}, + "source": [ + "## Clean up\n", + "\n", + "Set `CLEANUP = True` to delete this run's directory." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b6d3ca27", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-fqxhuh07.\n" + ] + } + ], + "source": [ + "if CLEANUP:\n", + " workspace.cleanup()\n", + "print(\"Removed this run's files.\" if CLEANUP else f\"Results retained in {run_dir}.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb deleted file mode 100644 index 7ca684cc0..000000000 --- a/examples/kumo-example-notebooks/structured-data-models/relational/fsi/notebooks/local_structured_data_models_fraud_detection_context_tuning.ipynb +++ /dev/null @@ -1,1509 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "9d40ab9c", - "metadata": {}, - "source": [ - "# Improve fraud recall on imbalanced accounts with KumoRelational\n", - "\n", - "Which accounts will be confirmed as fraud within 30 days? When fraud is rare, a pretrained relational model can rank accounts well but still flag almost none of them at the default 0.5 cutoff. This notebook applies four strategies to the in-context examples and the decision threshold, and measures the lift each one adds.\n", - "\n", - "Run locally with Python 3.12 or newer and [direct KumoRelational](https://nvidia.github.io/structured-data-models/api/generated/sdm.models.KumoRelational.html) from `structured-data-models`. A GPU is optional; on a laptop CPU the notebook takes about 20 minutes. The account and transaction tables are synthetic, and every metric is **demonstration only**.\n", - "\n", - "| Strategy | Lever |\n", - "| --- | --- |\n", - "| 1. Rebalance the context | Include every fraud example and test fraud-to-legitimate ratios, context sizes and fraud repetition. |\n", - "| 2. Ensemble across contexts | Keep the fraud examples fixed, vary the legitimate examples and average the predictions. |\n", - "| 3. Tune sampling | Prefer recent accounts, take each account's most recent transactions and vary the neighbor count. |\n", - "| 4. Tune the threshold | Choose the cutoff on validation data for maximum F1 or maximum recall at a target precision. |" - ] - }, - { - "cell_type": "markdown", - "id": "dcf7b0f0", - "metadata": {}, - "source": [ - "## Install and configure\n", - "\n", - "Install the packages into this notebook kernel. On CPU, relational sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the graph diagram needs the [Graphviz](https://graphviz.org/download/) system package. See [installation](https://nvidia.github.io/structured-data-models/install.html) for details." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "ee72fcf3", - "metadata": {}, - "outputs": [], - "source": [ - "%pip install structured-data-models pandas pyarrow scikit-learn matplotlib graphviz" - ] - }, - { - "cell_type": "markdown", - "id": "aa783b9b", - "metadata": {}, - "source": [ - "## Set the example parameters\n", - "\n", - "The time boundaries split accounts into a context pool, a validation window for choosing settings, and a later test window for reporting lift. The baseline mirrors a common first run: a random context at the natural fraud rate with the default cutoff." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a5463b49", - "metadata": {}, - "outputs": [], - "source": [ - "SEED = 7\n", - "N_ACCOUNTS = 80_000\n", - "N_SCORING_ACCOUNTS = 2_000\n", - "FRAUD_RATE = 0.005\n", - "START = \"2026-01-01\"\n", - "HISTORY_DAYS = 90\n", - "VALIDATION_START_DAY = 270\n", - "TEST_START_DAY = 310\n", - "\n", - "BASELINE_CONTEXT_SIZE = 5_000\n", - "LARGE_CONTEXT_SIZE = 10_000\n", - "FRAUD_REPEAT = 10\n", - "NUM_ESTIMATORS = 5\n", - "RECENT_CONTEXT_DAYS = 90\n", - "NEIGHBOR_OPTIONS = [16, 32]\n", - "\n", - "DEFAULT_THRESHOLD = 0.5\n", - "TARGET_PRECISION = 0.5\n", - "OUTPUT_PARENT = None\n", - "CLEANUP = False" - ] - }, - { - "cell_type": "markdown", - "id": "1f7aa4e4", - "metadata": {}, - "source": [ - "Import the libraries, select a device and create a new directory for this run's outputs." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "593c0250", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx\n" - ] - } - ], - "source": [ - "import json\n", - "import tempfile\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import sdm\n", - "import torch\n", - "from IPython.display import display\n", - "from sklearn.metrics import average_precision_score, f1_score, precision_recall_curve, precision_score, recall_score, roc_auc_score\n", - "\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "rng = np.random.default_rng(SEED)\n", - "workspace = tempfile.TemporaryDirectory(prefix=\"fraud-context-tuning-\", dir=OUTPUT_PARENT, delete=False)\n", - "run_dir = Path(workspace.name)\n", - "print(\"Device:\", device, \"| Results:\", run_dir)" - ] - }, - { - "cell_type": "markdown", - "id": "f46a046a", - "metadata": {}, - "source": [ - "## Generate synthetic example data\n", - "\n", - "Run the next cell to create accounts, card transactions and fraud labels, plus a separate set of new accounts reserved for batch scoring. You can skim the generation code; the Kumo workflow starts at **Build the relational data**.\n", - "\n", - "Each account has an observation date and 60 to 90 days of prior transactions. Most fraud accounts show a short burst of unusual activity in the final days before that date, and some legitimate accounts show similar bursts. The fraud pattern drifts mid-year from large daytime purchases to small, international, late-night purchases on new devices." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7fb12d07", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
historical_rowsreserved_rows
accounts800002000
transactions224920755910
\n", - "
" - ], - "text/plain": [ - " historical_rows reserved_rows\n", - "accounts 80000 2000\n", - "transactions 2249207 55910" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fraud rate: 0.53% (about 1 in 190)\n" - ] - } - ], - "source": [ - "PATTERNS = {\"early\": (6.0, 0.6, 0.15, 14, 4, 0.25), \"late\": (3.0, 0.6, 0.65, 2, 2, 0.55)}\n", - "DRIFT_DAY = 215\n", - "\n", - "\n", - "def simulate_transactions(account_ids, anchors, counts, window_days, amount_mu, amount_sd, intl_p, hour_mu, hour_sd, device_p):\n", - " owners = np.repeat(account_ids, counts)\n", - " return pd.DataFrame({\n", - " \"account_id\": owners,\n", - " \"timestamp\": np.repeat(anchors, counts) - pd.to_timedelta(rng.uniform(0, window_days, len(owners)), unit=\"D\"),\n", - " \"amount\": rng.lognormal(amount_mu, amount_sd, len(owners)).round(2),\n", - " \"is_international\": (rng.random(len(owners)) < intl_p).astype(float),\n", - " \"hour_of_day\": rng.normal(hour_mu, hour_sd, len(owners)).clip(0, 23).round(),\n", - " \"new_device\": (rng.random(len(owners)) < device_p).astype(float),\n", - " })\n", - "\n", - "\n", - "def simulate_accounts(account_ids, anchors):\n", - " n = len(account_ids)\n", - " is_fraud = rng.random(n) < FRAUD_RATE\n", - " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", - " accounts = pd.DataFrame({\n", - " \"account_id\": account_ids,\n", - " \"account_age_days\": np.where(is_fraud, rng.gamma(2.0, 150, n), rng.gamma(3.0, 300, n)).round(),\n", - " \"kyc_tier\": rng.integers(1, 4, n).astype(float),\n", - " })\n", - " parts = [simulate_transactions(account_ids, anchors.values, rng.poisson(24, n) + 4, HISTORY_DAYS, 3.5, 0.9, 0.05, 14, 4, 0.03)]\n", - " bursty_fraud = is_fraud & (rng.random(n) < 0.9)\n", - " lookalikes = ~is_fraud & (rng.random(n) < 0.03)\n", - " for mask, mean_count in ((bursty_fraud, 4), (lookalikes, 3)):\n", - " for period, selected in ((\"early\", mask & ~late), (\"late\", mask & late)):\n", - " parts.append(simulate_transactions(\n", - " account_ids[selected], anchors.values[selected], rng.poisson(mean_count, selected.sum()) + 1, 5, *PATTERNS[period]\n", - " ))\n", - " transactions = pd.concat(parts, ignore_index=True).sort_values(\"timestamp\", ignore_index=True)\n", - " transactions[\"timestamp\"] = transactions.timestamp.dt.floor(\"s\")\n", - " labels = pd.DataFrame({\"account_id\": account_ids, \"timestamp\": anchors, \"is_fraud\": np.where(is_fraud, \"fraud\", \"legit\")})\n", - " return accounts, transactions, labels\n", - "\n", - "\n", - "history_anchors = pd.Timestamp(START) + pd.to_timedelta(rng.integers(60, 365, N_ACCOUNTS), unit=\"D\")\n", - "accounts, transactions, labels = simulate_accounts(np.arange(N_ACCOUNTS), history_anchors)\n", - "transactions.insert(0, \"transaction_id\", np.arange(len(transactions)))\n", - "\n", - "scoring_anchors = pd.DatetimeIndex([pd.Timestamp(START) + pd.Timedelta(days=365)] * N_SCORING_ACCOUNTS)\n", - "new_accounts, new_transactions, _ = simulate_accounts(np.arange(N_ACCOUNTS, N_ACCOUNTS + N_SCORING_ACCOUNTS), scoring_anchors)\n", - "new_transactions.insert(0, \"transaction_id\", np.arange(len(transactions), len(transactions) + len(new_transactions)))\n", - "\n", - "display(pd.DataFrame({\n", - " \"historical_rows\": {\"accounts\": len(accounts), \"transactions\": len(transactions)},\n", - " \"reserved_rows\": {\"accounts\": len(new_accounts), \"transactions\": len(new_transactions)},\n", - "}))\n", - "print(f\"Fraud rate: {labels.is_fraud.eq('fraud').mean():.2%} (about 1 in {round(1 / labels.is_fraud.eq('fraud').mean())})\")" - ] - }, - { - "cell_type": "markdown", - "id": "2eab2259", - "metadata": {}, - "source": [ - "## Build the relational data\n", - "\n", - "Link transactions to accounts and convert both tables to tensors. KumoRelational uses numerical and datetime features, so the flags are stored as 0/1 numbers. The sampler uses transaction timestamps to keep every neighbor before the account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f96988be", - "metadata": {}, - "outputs": [], - "source": [ - "ACCOUNT_STYPES = {\"account_id\": \"id\", \"account_age_days\": \"numerical\", \"kyc_tier\": \"numerical\"}\n", - "TRANSACTION_STYPES = {\n", - " \"transaction_id\": \"id\", \"account_id\": \"id\", \"timestamp\": \"datetime\", \"amount\": \"numerical\",\n", - " \"is_international\": \"numerical\", \"hour_of_day\": \"numerical\", \"new_device\": \"numerical\",\n", - "}\n", - "RELATIONSHIPS = [{\"left_table\": \"transactions\", \"left_column\": \"account_id\", \"right_table\": \"accounts\", \"right_column\": \"account_id\"}]\n", - "TASK_LINK = {\"task_column\": \"account_id\", \"table\": \"accounts\", \"table_column\": \"account_id\"}\n", - "\n", - "\n", - "def build_relational_data(account_frame, transaction_frame):\n", - " return sdm.RelationalData(\n", - " tables={\n", - " \"accounts\": sdm.TableTensor.from_pandas(account_frame, stypes=ACCOUNT_STYPES),\n", - " \"transactions\": sdm.TableTensor.from_pandas(transaction_frame, stypes=TRANSACTION_STYPES),\n", - " },\n", - " relationships=RELATIONSHIPS,\n", - " )\n", - "\n", - "\n", - "data = build_relational_data(accounts, transactions)\n", - "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", - "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"is_fraud\": \"categorical\"})" - ] - }, - { - "cell_type": "markdown", - "id": "dc1be8ce", - "metadata": {}, - "source": [ - "Inspect the schema the model will traverse: each account links to its transactions." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "01791271", - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "accounts\n", - "\n", - "accounts\n", - "\n", - "account_id: id\n", - "account_age_days: numerical\n", - "kyc_tier: numerical\n", - "\n", - "\n", - "\n", - "transactions\n", - "\n", - "transactions\n", - "\n", - "transaction_id: id\n", - "account_id: id\n", - "timestamp: datetime\n", - "amount: numerical\n", - "is_international: numerical\n", - "hour_of_day: numerical\n", - "new_device: numerical\n", - "\n", - "\n", - "\n", - "transactions--accounts\n", - "\n", - " account_id <> account_id \n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.to_graphviz()" - ] - }, - { - "cell_type": "markdown", - "id": "e4836b1d", - "metadata": {}, - "source": [ - "## Split accounts by time\n", - "\n", - "Accounts observed before day 270 form the labeled context pool. Validation accounts (days 270 to 309) are used only to choose settings and thresholds; test accounts (day 310 onward) report the result. This mirrors scoring future accounts with labeled history." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bb168100", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
accountsfraud_accounts
context pool54882283
validation1056555
test1455382
\n", - "
" - ], - "text/plain": [ - " accounts fraud_accounts\n", - "context pool 54882 283\n", - "validation 10565 55\n", - "test 14553 82" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", - "is_fraud = labels.is_fraud.eq(\"fraud\").to_numpy()\n", - "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", - "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", - "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", - "fraud_pool = pool_rows[is_fraud[pool_rows]]\n", - "legit_pool = pool_rows[~is_fraud[pool_rows]]\n", - "y_val, y_test = is_fraud[val_rows], is_fraud[test_rows]\n", - "\n", - "display(pd.DataFrame({\n", - " \"accounts\": [len(pool_rows), len(val_rows), len(test_rows)],\n", - " \"fraud_accounts\": [is_fraud[pool_rows].sum(), y_val.sum(), y_test.sum()],\n", - "}, index=[\"context pool\", \"validation\", \"test\"]))" - ] - }, - { - "cell_type": "markdown", - "id": "2b3b63a9", - "metadata": {}, - "source": [ - "## Define the scoring and evaluation helpers\n", - "\n", - "`score_contexts` fits KumoRelational on each context, scores the query accounts and averages the fraud probability across contexts. A single context is an ensemble of one. `num_neighbors` and `temporal_strategy` control which transactions the [sampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html) attaches to each account." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "bcf90983", - "metadata": {}, - "outputs": [], - "source": [ - "model = sdm.models.KumoRelational(device=device)\n", - "evaluation_query = task_table[torch.as_tensor(np.concatenate([val_rows, test_rows]))].drop_columns(\"is_fraud\")\n", - "\n", - "\n", - "def score_contexts(contexts, query, relational_sampler, num_neighbors=8, temporal_strategy=\"uniform\", batch_size=10_000):\n", - " options = dict(task_link=TASK_LINK, num_neighbors=[num_neighbors], task_time_column=\"timestamp\", temporal_strategy=temporal_strategy)\n", - " member_probabilities = []\n", - " for context_rows in contexts:\n", - " torch.manual_seed(SEED)\n", - " context, related = relational_sampler(task_table[torch.as_tensor(context_rows)], **options).to(device)\n", - " model.fit(x=context.drop_columns(\"is_fraud\"), y=context[\"is_fraud\"], related_tables=related)\n", - " batches = []\n", - " for query_batch in query.split(batch_size, -2):\n", - " out = model.predict(*relational_sampler(query_batch, **options).to(device))\n", - " batches.append(out.numerical[:, list(out.columns[sdm.Stype.numerical]).index(\"fraud\")].float().cpu().numpy())\n", - " member_probabilities.append(np.concatenate(batches))\n", - " return np.mean(member_probabilities, axis=0)\n", - "\n", - "\n", - "def score_evaluation(contexts, **options):\n", - " probabilities = score_contexts(contexts, evaluation_query, sampler, **options)\n", - " return probabilities[: len(val_rows)], probabilities[len(val_rows):]\n", - "\n", - "\n", - "def metrics(y_true, probability, threshold):\n", - " flagged = probability >= threshold\n", - " return {\n", - " \"average_precision\": average_precision_score(y_true, probability),\n", - " \"auroc\": roc_auc_score(y_true, probability),\n", - " \"precision\": precision_score(y_true, flagged, zero_division=0),\n", - " \"recall\": recall_score(y_true, flagged),\n", - " \"f1\": f1_score(y_true, flagged),\n", - " \"threshold\": threshold,\n", - " }\n", - "\n", - "\n", - "def compose_context(fraud_rows, legit_rows, n_legit, fraud_repeat=1):\n", - " return np.concatenate([np.tile(fraud_rows, fraud_repeat), rng.choice(legit_rows, n_legit, replace=False)])\n", - "\n", - "\n", - "stages = {}" - ] - }, - { - "cell_type": "markdown", - "id": "b79128ff", - "metadata": {}, - "source": [ - "## Score the baseline\n", - "\n", - "Draw a random context at the natural fraud rate, which contains only a few dozen fraud examples. Average precision and AUROC measure ranking quality without a threshold; precision, recall and F1 use the default 0.5 cutoff." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1e1b5aa0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fraud examples in the baseline context: 18 of 5000\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.00.00.00.5
\n", - "
" - ], - "text/plain": [ - " average_precision auroc precision recall f1 threshold\n", - "Baseline 0.035 0.852 0.0 0.0 0.0 0.5" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "baseline_context = rng.choice(pool_rows, BASELINE_CONTEXT_SIZE, replace=False)\n", - "baseline_val, baseline_test = score_evaluation([baseline_context])\n", - "stages[\"Baseline\"] = metrics(y_test, baseline_test, DEFAULT_THRESHOLD)\n", - "print(f\"Fraud examples in the baseline context: {is_fraud[baseline_context].sum()} of {BASELINE_CONTEXT_SIZE}\")\n", - "display(pd.DataFrame(stages).T.round(3))" - ] - }, - { - "cell_type": "markdown", - "id": "e4033d9a", - "metadata": {}, - "source": [ - "The ranking is reasonable, but with so few fraud examples the model rarely assigns a probability above 0.5, so recall is low. The next four strategies address this. Metrics are **demonstration only**.\n", - "\n", - "## Strategy 1: rebalance the in-context examples\n", - "\n", - "Every candidate includes all fraud accounts from the pool. The ratio candidates test 1:1, 1:5 and 1:20; the large candidate fills a 10,000-row context; the repeated candidate includes each fraud account ten times. Choose the candidate with the highest validation average precision." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "7913d842", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
validation_average_precisionvalidation_recall_at_0.5validation_precision_at_0.5
1:10.3180.9090.028
1:50.3650.6730.119
1:200.3730.5090.311
All fraud, 10,000 rows0.3680.4910.281
Fraud x10, 10,000 rows0.3320.8360.062
\n", - "
" - ], - "text/plain": [ - " validation_average_precision \\\n", - "1:1 0.318 \n", - "1:5 0.365 \n", - "1:20 0.373 \n", - "All fraud, 10,000 rows 0.368 \n", - "Fraud x10, 10,000 rows 0.332 \n", - "\n", - " validation_recall_at_0.5 validation_precision_at_0.5 \n", - "1:1 0.909 0.028 \n", - "1:5 0.673 0.119 \n", - "1:20 0.509 0.311 \n", - "All fraud, 10,000 rows 0.491 0.281 \n", - "Fraud x10, 10,000 rows 0.836 0.062 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Selected context design: 1:20\n" - ] - } - ], - "source": [ - "n_fraud = len(fraud_pool)\n", - "context_designs = {\n", - " \"1:1\": (1, n_fraud),\n", - " \"1:5\": (1, 5 * n_fraud),\n", - " \"1:20\": (1, 20 * n_fraud),\n", - " f\"All fraud, {LARGE_CONTEXT_SIZE:,} rows\": (1, LARGE_CONTEXT_SIZE - n_fraud),\n", - " f\"Fraud x{FRAUD_REPEAT}, {LARGE_CONTEXT_SIZE:,} rows\": (FRAUD_REPEAT, LARGE_CONTEXT_SIZE - FRAUD_REPEAT * n_fraud),\n", - "}\n", - "design_scores = {}\n", - "for name, (fraud_repeat, n_legit) in context_designs.items():\n", - " design_val, design_test = score_evaluation([compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)])\n", - " design_scores[name] = (design_val, design_test)\n", - "\n", - "comparison = pd.DataFrame({\n", - " name: {\n", - " \"validation_average_precision\": average_precision_score(y_val, design_val),\n", - " \"validation_recall_at_0.5\": recall_score(y_val, design_val >= DEFAULT_THRESHOLD),\n", - " \"validation_precision_at_0.5\": precision_score(y_val, design_val >= DEFAULT_THRESHOLD, zero_division=0),\n", - " }\n", - " for name, (design_val, _) in design_scores.items()\n", - "}).T\n", - "best_design = comparison.validation_average_precision.idxmax()\n", - "fraud_repeat, n_legit = context_designs[best_design]\n", - "stages[\"+ Rebalanced context\"] = metrics(y_test, design_scores[best_design][1], DEFAULT_THRESHOLD)\n", - "display(comparison.round(3))\n", - "print(\"Selected context design:\", best_design)" - ] - }, - { - "cell_type": "markdown", - "id": "671b1ced", - "metadata": {}, - "source": [ - "Every rebalanced design ranks better than the baseline. Lower legitimate ratios also move probabilities upward, raising recall at 0.5 at the cost of precision. That shift is corrected in strategy 4, so the selection uses average precision, which ignores the cutoff.\n", - "\n", - "## Strategy 2: ensemble across contexts\n", - "\n", - "Keep the same fraud accounts in every context and draw a different set of legitimate accounts for each. Averaging the members reduces the variance that comes from any single draw of legitimate examples. See [ensembling in-context learners](https://nvidia.github.io/structured-data-models/icl.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "9765b04c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Validation AP per member: [0.365 0.355 0.359 0.378 0.37 ]\n", - "Validation AP of the ensemble: 0.372\n" - ] - } - ], - "source": [ - "ensemble_contexts = [compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat) for _ in range(NUM_ESTIMATORS)]\n", - "member_scores = [score_evaluation([context]) for context in ensemble_contexts]\n", - "member_val_ap = [average_precision_score(y_val, member_val) for member_val, _ in member_scores]\n", - "ensemble_val = np.mean([member_val for member_val, _ in member_scores], axis=0)\n", - "ensemble_test = np.mean([member_test for _, member_test in member_scores], axis=0)\n", - "stages[\"+ Context ensemble\"] = metrics(y_test, ensemble_test, DEFAULT_THRESHOLD)\n", - "print(\"Validation AP per member:\", np.round(member_val_ap, 3))\n", - "print(f\"Validation AP of the ensemble: {average_precision_score(y_val, ensemble_val):.3f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "9e6c24f2", - "metadata": {}, - "source": [ - "Ensembling adds little over the best member here; its main benefit is a result that depends less on any single draw of legitimate accounts.\n", - "\n", - "## Strategy 3: tune context and neighbor sampling\n", - "\n", - "Compare single contexts on validation data, keeping each change only if it improves average precision:\n", - "\n", - "* **Recent accounts:** build the context from accounts observed in the last 90 days of the pool, at the same legitimate-to-fraud ratio. Recent examples can better match drifting fraud patterns, but the window holds fewer fraud accounts. Draw both classes from the same window; otherwise the observation date alone can separate them.\n", - "* **Recent transactions:** `temporal_strategy=\"last\"` attaches each account's most recent transactions instead of a uniform sample of its history.\n", - "* **Neighbor count:** try more transactions per account." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "b3d2854f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
changerecent_accountsnum_neighborstemporal_strategyvalidation_average_precision
0Current settingsFalse8uniform0.350
1Recent accountsTrue8uniform0.261
2Most recent transactionsFalse8last0.548
316 neighborsFalse16last0.527
432 neighborsFalse32last0.581
\n", - "
" - ], - "text/plain": [ - " change recent_accounts num_neighbors temporal_strategy \\\n", - "0 Current settings False 8 uniform \n", - "1 Recent accounts True 8 uniform \n", - "2 Most recent transactions False 8 last \n", - "3 16 neighbors False 16 last \n", - "4 32 neighbors False 32 last \n", - "\n", - " validation_average_precision \n", - "0 0.350 \n", - "1 0.261 \n", - "2 0.548 \n", - "3 0.527 \n", - "4 0.581 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Selected sampling settings: {'use_recent': False, 'num_neighbors': 32, 'temporal_strategy': 'last'}\n" - ] - } - ], - "source": [ - "recent_rows = pool_rows[observation_day[pool_rows] >= VALIDATION_START_DAY - RECENT_CONTEXT_DAYS]\n", - "recent_fraud, recent_legit = recent_rows[is_fraud[recent_rows]], recent_rows[~is_fraud[recent_rows]]\n", - "legit_per_fraud = n_legit / n_fraud\n", - "\n", - "\n", - "def candidate_context(use_recent):\n", - " if use_recent:\n", - " return compose_context(recent_fraud, recent_legit, round(legit_per_fraud * len(recent_fraud)), fraud_repeat)\n", - " return compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)\n", - "\n", - "\n", - "trials = []\n", - "\n", - "\n", - "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", - " trial_val, _ = score_evaluation([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", - " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", - " \"temporal_strategy\": temporal_strategy, \"validation_average_precision\": average_precision_score(y_val, trial_val)})\n", - " return trials[-1][\"validation_average_precision\"]\n", - "\n", - "\n", - "settings = {\"use_recent\": False, \"num_neighbors\": 8, \"temporal_strategy\": \"uniform\"}\n", - "best_ap = try_settings(\"Current settings\", **settings)\n", - "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", - " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", - "]:\n", - " trial_ap = try_settings(change, **{**settings, **update})\n", - " if trial_ap > best_ap:\n", - " settings, best_ap = {**settings, **update}, trial_ap\n", - "\n", - "display(pd.DataFrame(trials).round(3))\n", - "print(\"Selected sampling settings:\", settings)" - ] - }, - { - "cell_type": "markdown", - "id": "449b7779", - "metadata": {}, - "source": [ - "A change is kept only when it improves validation average precision, so a setting that helps one portfolio may be rejected for another.\n", - "\n", - "Rebuild the ensemble with the selected settings: the fraud accounts stay fixed while the legitimate accounts vary across members." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9b37fd5b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.0000.0000.0000.5
+ Rebalanced context0.2950.9450.3240.4150.3640.5
+ Context ensemble0.2990.9450.3440.4020.3710.5
+ Sampling settings0.5400.9890.2810.8290.4200.5
\n", - "
" - ], - "text/plain": [ - " average_precision auroc precision recall f1 \\\n", - "Baseline 0.035 0.852 0.000 0.000 0.000 \n", - "+ Rebalanced context 0.295 0.945 0.324 0.415 0.364 \n", - "+ Context ensemble 0.299 0.945 0.344 0.402 0.371 \n", - "+ Sampling settings 0.540 0.989 0.281 0.829 0.420 \n", - "\n", - " threshold \n", - "Baseline 0.5 \n", - "+ Rebalanced context 0.5 \n", - "+ Context ensemble 0.5 \n", - "+ Sampling settings 0.5 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", - "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", - "final_val, final_test = score_evaluation(final_contexts, **sampling_options)\n", - "stages[\"+ Sampling settings\"] = metrics(y_test, final_test, DEFAULT_THRESHOLD)\n", - "display(pd.DataFrame(stages).T.round(3))" - ] - }, - { - "cell_type": "markdown", - "id": "a6037ebc", - "metadata": {}, - "source": [ - "## Strategy 4: tune the decision threshold\n", - "\n", - "The model returns class probabilities, so the cutoff can be chosen outside the model. Sweep thresholds on validation data and choose two operating points: maximum F1, and maximum recall while precision stays at or above `TARGET_PRECISION`. The second suits fraud teams with a fixed review capacity. Apply both to the test accounts." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "b59ad480", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Max-F1 threshold: 0.614 | Precision-target threshold: 0.685\n" - ] - } - ], - "source": [ - "val_precision, val_recall, candidate_thresholds = precision_recall_curve(y_val, final_val)\n", - "val_precision, val_recall = val_precision[:-1], val_recall[:-1]\n", - "val_f1 = 2 * val_precision * val_recall / np.clip(val_precision + val_recall, 1e-12, None)\n", - "f1_threshold = candidate_thresholds[np.argmax(val_f1)]\n", - "meets_precision = np.flatnonzero(val_precision >= TARGET_PRECISION)\n", - "precision_threshold = candidate_thresholds[meets_precision[np.argmax(val_recall[meets_precision])]] if len(meets_precision) else f1_threshold\n", - "\n", - "stages[\"+ Threshold for max F1\"] = metrics(y_test, final_test, f1_threshold)\n", - "stages[f\"+ Threshold for precision >= {TARGET_PRECISION:.0%}\"] = metrics(y_test, final_test, precision_threshold)\n", - "print(f\"Max-F1 threshold: {f1_threshold:.3f} | Precision-target threshold: {precision_threshold:.3f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "0e2f63e9", - "metadata": {}, - "source": [ - "## Compare the lift\n", - "\n", - "Each row adds one strategy to the row above, measured on the same test accounts. Average precision tracks ranking quality; recall and F1 show what the fraud team receives at the chosen cutoff. Values are **demonstration only** and come from synthetic data. A threshold chosen on validation data can land slightly off its precision target on later accounts, so recheck it on fresh labels before adopting it as policy." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "8888b467", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
average_precisionaurocprecisionrecallf1threshold
Baseline0.0350.8520.0000.0000.0000.500
+ Rebalanced context0.2950.9450.3240.4150.3640.500
+ Context ensemble0.2990.9450.3440.4020.3710.500
+ Sampling settings0.5400.9890.2810.8290.4200.500
+ Threshold for max F10.5400.9890.3730.7680.5020.614
+ Threshold for precision >= 50%0.5400.9890.4120.6830.5140.685
\n", - "
" - ], - "text/plain": [ - " average_precision auroc precision recall \\\n", - "Baseline 0.035 0.852 0.000 0.000 \n", - "+ Rebalanced context 0.295 0.945 0.324 0.415 \n", - "+ Context ensemble 0.299 0.945 0.344 0.402 \n", - "+ Sampling settings 0.540 0.989 0.281 0.829 \n", - "+ Threshold for max F1 0.540 0.989 0.373 0.768 \n", - "+ Threshold for precision >= 50% 0.540 0.989 0.412 0.683 \n", - "\n", - " f1 threshold \n", - "Baseline 0.000 0.500 \n", - "+ Rebalanced context 0.364 0.500 \n", - "+ Context ensemble 0.371 0.500 \n", - "+ Sampling settings 0.420 0.500 \n", - "+ Threshold for max F1 0.502 0.614 \n", - "+ Threshold for precision >= 50% 0.514 0.685 " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average precision: 0.035 -> 0.540; recall: 0.000 -> 0.768; F1: 0.000 -> 0.502\n" - ] - } - ], - "source": [ - "summary = pd.DataFrame(stages).T\n", - "display(summary.round(3))\n", - "baseline_row, final_row = summary.iloc[0], summary.loc[\"+ Threshold for max F1\"]\n", - "print(f\"Average precision: {baseline_row.average_precision:.3f} -> {final_row.average_precision:.3f}; \"\n", - " f\"recall: {baseline_row.recall:.3f} -> {final_row.recall:.3f}; F1: {baseline_row.f1:.3f} -> {final_row.f1:.3f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "96592149", - "metadata": {}, - "source": [ - "Plot the three headline metrics for each stage on separate axes." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "435b00a0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)\n", - "for axis, (column, title) in zip(axes, [(\"average_precision\", \"Average precision\"), (\"recall\", \"Recall\"), (\"f1\", \"F1\")]):\n", - " values = summary[column].to_numpy()[::-1]\n", - " axis.barh(summary.index[::-1], values, color=\"#2a78d6\", height=0.6)\n", - " for position, value in enumerate(values):\n", - " axis.text(value + 0.01, position, f\"{value:.2f}\", va=\"center\", fontsize=9, color=\"#52514e\")\n", - " axis.set_xlim(0, 1)\n", - " axis.set_title(title, loc=\"left\", fontsize=11)\n", - " axis.spines[[\"top\", \"right\"]].set_visible(False)\n", - " axis.grid(axis=\"x\", color=\"#e4e3df\", linewidth=0.8)\n", - " axis.set_axisbelow(True)\n", - "fig.suptitle(\"Test-set lift by strategy (synthetic data, demonstration only)\", x=0.01, ha=\"left\", fontsize=12)\n", - "fig.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a0246423", - "metadata": {}, - "source": [ - "## Batch predictions\n", - "\n", - "Append the reserved accounts and their transactions to copies of the original tables, then rebuild the relational data and sampler. New accounts have no labels and never enter the context." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "a98c162d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Accounts to score: 2,000; context accounts per member: 5,943\n" - ] - } - ], - "source": [ - "scoring_accounts = pd.concat([accounts, new_accounts], ignore_index=True)\n", - "scoring_transactions = pd.concat([transactions, new_transactions], ignore_index=True)\n", - "assert set(new_accounts.account_id).isdisjoint(accounts.account_id)\n", - "assert set(new_transactions.transaction_id).isdisjoint(transactions.transaction_id)\n", - "scoring_sampler = build_relational_data(scoring_accounts, scoring_transactions).sampler(time_columns={\"transactions\": \"timestamp\"})\n", - "scoring_query = sdm.TableTensor.from_pandas(\n", - " pd.DataFrame({\"account_id\": new_accounts.account_id, \"timestamp\": scoring_anchors}),\n", - " stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\"},\n", - ")\n", - "print(f\"Accounts to score: {len(new_accounts):,}; context accounts per member: {len(final_contexts[0]):,}\")" - ] - }, - { - "cell_type": "markdown", - "id": "6038aa3e", - "metadata": {}, - "source": [ - "Score the new accounts with the final ensemble and sampling settings." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "7e3a8d27", - "metadata": {}, - "outputs": [], - "source": [ - "batch_probability = score_contexts(final_contexts, scoring_query, scoring_sampler, **sampling_options)" - ] - }, - { - "cell_type": "markdown", - "id": "995bdb57", - "metadata": {}, - "source": [ - "### Inspect and save the scores\n", - "\n", - "Expect one row per new account in input order. `fraud_probability` is the ensemble's average probability; `review_flag` applies the precision-target threshold chosen on validation data. The flag is illustrative, not a business policy." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "08724d72", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
account_idfraud_probabilityreview_flag
1660816600.967997True
1802818020.947694True
1532815320.932520True
1805818050.925285True
623806230.924746True
\n", - "
" - ], - "text/plain": [ - " account_id fraud_probability review_flag\n", - "1660 81660 0.967997 True\n", - "1802 81802 0.947694 True\n", - "1532 81532 0.932520 True\n", - "1805 81805 0.925285 True\n", - "623 80623 0.924746 True" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Flagged 28 of 2,000 accounts; saved to /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx/fraud_predictions.parquet\n" - ] - } - ], - "source": [ - "predictions = pd.DataFrame({\n", - " \"account_id\": new_accounts.account_id.to_numpy(),\n", - " \"fraud_probability\": batch_probability,\n", - " \"review_flag\": batch_probability >= precision_threshold,\n", - "})\n", - "assert len(predictions) == len(new_accounts) and predictions.account_id.is_unique\n", - "assert np.isfinite(predictions.fraud_probability).all() and predictions.fraud_probability.between(0, 1).all()\n", - "prediction_path = run_dir / \"fraud_predictions.parquet\"\n", - "predictions.to_parquet(prediction_path, index=False)\n", - "display(predictions.sort_values(\"fraud_probability\", ascending=False).head())\n", - "print(f\"Flagged {predictions.review_flag.sum()} of {len(predictions):,} accounts; saved to {prediction_path}\")" - ] - }, - { - "cell_type": "markdown", - "id": "7fef0951", - "metadata": {}, - "source": [ - "## Retain the context\n", - "\n", - "KumoRelational has no trained weights to save; the context and settings define the model. Save the context account IDs, sampling settings and thresholds, then reload them to confirm they rebuild the same contexts." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "a64b8fad", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Context configuration saved and reloaded from /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx/context_config.json\n" - ] - } - ], - "source": [ - "context_config = {\n", - " \"context_account_ids\": [labels.account_id.to_numpy()[rows].tolist() for rows in final_contexts],\n", - " \"sampling_options\": sampling_options,\n", - " \"thresholds\": {\"max_f1\": float(f1_threshold), \"precision_target\": float(precision_threshold)},\n", - "}\n", - "config_path = run_dir / \"context_config.json\"\n", - "config_path.write_text(json.dumps(context_config))\n", - "\n", - "reloaded = json.loads(config_path.read_text())\n", - "row_by_account = pd.Series(np.arange(len(labels)), index=labels.account_id)\n", - "reloaded_contexts = [row_by_account.loc[ids].to_numpy() for ids in reloaded[\"context_account_ids\"]]\n", - "assert all(np.array_equal(a, b) for a, b in zip(reloaded_contexts, final_contexts))\n", - "print(\"Context configuration saved and reloaded from\", config_path)" - ] - }, - { - "cell_type": "markdown", - "id": "956129ec", - "metadata": {}, - "source": [ - "## Keep or remove this run's files\n", - "\n", - "The output directory is kept by default. Set `CLEANUP = True` to remove only the directory created by this run; the cached model checkpoint stays available." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "c6d1ac4b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-2ecclbsx.\n" - ] - } - ], - "source": [ - "if CLEANUP:\n", - " workspace.cleanup()\n", - "print(\"Removed this run's files.\" if CLEANUP else f\"Results retained in {run_dir}.\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From e3527f4be515ea04fe8c329e452a6c0a95a5c26d Mon Sep 17 00:00:00 2001 From: aliu65803 Date: Wed, 18 Nov 2026 18:40:40 -0600 Subject: [PATCH 3/5] Add KumoRelational regression tuning example notebook Demonstrates context composition, context ensembling, neighbor sampling and per-configuration output-quantile selection on a synthetic next-30-day spend task over a five-table banking graph. Indexes it with the imbalanced-data notebook under relational cross-industry notebooks and removes the entry mistakenly added under time series. Co-Authored-By: Claude Opus 5.5 --- .../structured-data-models/README.md | 7 +- ...ctured_data_models_regression_tuning.ipynb | 1624 +++++++++++++++++ 2 files changed, 1625 insertions(+), 6 deletions(-) create mode 100644 examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb diff --git a/examples/kumo-example-notebooks/structured-data-models/README.md b/examples/kumo-example-notebooks/structured-data-models/README.md index 228f4169e..c63b0eca0 100644 --- a/examples/kumo-example-notebooks/structured-data-models/README.md +++ b/examples/kumo-example-notebooks/structured-data-models/README.md @@ -19,6 +19,7 @@ Client examples require an existing endpoint; they do not provision one. | Example | Deployment | Scope | | --- | --- | --- | | [Improve KumoRelational performance on imbalanced data, with a fraud example](relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb) | Local | Model workflow | +| [Improve KumoRelational regression accuracy, with a spend-forecasting example](relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb) | Local | Model workflow | #### SDK code examples @@ -168,12 +169,6 @@ Client examples require an existing endpoint; they do not provision one. ### Cross-industry -#### Notebooks - -| Example | Deployment | Scope | -| --- | --- | --- | -| [Improve KumoRelational performance on imbalanced data, with a fraud example](relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb) | Local | Model workflow | - #### SDK code examples | Example | Deployment | Scope | diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb new file mode 100644 index 000000000..14e2a73d0 --- /dev/null +++ b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb @@ -0,0 +1,1624 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1f14766e", + "metadata": {}, + "source": [ + "# Improve KumoRelational regression accuracy\n", + "\n", + "KumoRelational, a relational foundation model (RFM), predicts from labeled in-context examples. This notebook demonstrates four levers and measures the lift of each, using a banking example: how much will each account spend in the next 30 days?\n", + "\n", + "| Strategy | What changes |\n", + "| --- | --- |\n", + "| 1. Compose the context | Context size, stratification by target band, and oversampling of the high-value tail. |\n", + "| 2. Ensemble contexts | Average the quantile predictions of several context draws. |\n", + "| 3. Tune sampling | Recent entities, most recent neighbors, neighbor count. |\n", + "| 4. Choose the output quantile | Pick the reported quantile on validation data for each configuration. |\n", + "\n", + "Runs locally with Python 3.12+ and [direct KumoRelational](https://nvidia.github.io/structured-data-models/api/generated/sdm.models.KumoRelational.html), in about 20 minutes on CPU. Data is synthetic; metrics are **demonstration only**." + ] + }, + { + "cell_type": "markdown", + "id": "611aaa51", + "metadata": {}, + "source": [ + "## Install and configure\n", + "\n", + "On CPU, sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "52d2488b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:53:53.568174Z", + "iopub.status.busy": "2026-11-18T23:53:53.568075Z", + "iopub.status.idle": "2026-11-18T23:53:55.457414Z", + "shell.execute_reply": "2026-11-18T23:53:55.456554Z" + } + }, + "outputs": [], + "source": [ + "%pip install structured-data-models pandas pyarrow scikit-learn scipy matplotlib graphviz" + ] + }, + { + "cell_type": "markdown", + "id": "a60fff01", + "metadata": {}, + "source": [ + "## Set the parameters\n", + "\n", + "Accounts are split by observation date into a context pool, a validation window for choosing settings and quantiles, and a test window for reporting. `TOP_SHARE` defines the high-value tail used for tail metrics and stratification." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "20403f80", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:53:55.459494Z", + "iopub.status.busy": "2026-11-18T23:53:55.459342Z", + "iopub.status.idle": "2026-11-18T23:53:55.462506Z", + "shell.execute_reply": "2026-11-18T23:53:55.461996Z" + } + }, + "outputs": [], + "source": [ + "SEED = 7\n", + "N_ACCOUNTS = 80_000\n", + "START = \"2026-01-01\"\n", + "HISTORY_DAYS = 90\n", + "VALIDATION_START_DAY = 270\n", + "TEST_START_DAY = 310\n", + "\n", + "BASELINE_CONTEXT_SIZE = 5_000\n", + "LARGE_CONTEXT_SIZE = 10_000\n", + "ROWS_PER_BAND = 2_500\n", + "TOP_REPEAT = 3\n", + "TOP_SHARE = 0.02\n", + "NUM_ESTIMATORS = 5\n", + "RECENT_CONTEXT_DAYS = 90\n", + "FIRST_HOP_NEIGHBORS = 8\n", + "SECOND_HOP_NEIGHBORS = 4\n", + "NEIGHBOR_OPTIONS = [16]\n", + "\n", + "QUANTILES = [round(q, 2) for q in [0.05 * i for i in range(1, 20)]]\n", + "UNDER_PREDICTION_COST = 3.0\n", + "OUTPUT_PARENT = None\n", + "CLEANUP = False" + ] + }, + { + "cell_type": "markdown", + "id": "8f836116", + "metadata": {}, + "source": [ + "Import the libraries and create an output directory for this run." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "14c39647", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:53:55.464269Z", + "iopub.status.busy": "2026-11-18T23:53:55.464144Z", + "iopub.status.idle": "2026-11-18T23:54:04.482493Z", + "shell.execute_reply": "2026-11-18T23:54:04.482015Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-73ej8kxe\n" + ] + } + ], + "source": [ + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import sdm\n", + "import torch\n", + "from IPython.display import display\n", + "from scipy.stats import spearmanr\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "rng = np.random.default_rng(SEED)\n", + "workspace = tempfile.TemporaryDirectory(prefix=\"spend-context-tuning-\", dir=OUTPUT_PARENT, delete=False)\n", + "run_dir = Path(workspace.name)\n", + "print(\"Device:\", device, \"| Results:\", run_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "6d17fce3", + "metadata": {}, + "source": [ + "## Generate synthetic example data\n", + "\n", + "Run the next cell to create five tables: customers, accounts, transactions, merchants and devices. You can skim it; the workflow starts at **Build the relational data**.\n", + "\n", + "About a third of accounts go quiet before their observation date and spend nothing in the next 30 days. About 1% are high spenders who shop at premium merchants. Future spend tracks each account's activity in its last 10 days, and high spenders move from in-store to online premium merchants mid-year." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3efd059e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:04.483900Z", + "iopub.status.busy": "2026-11-18T23:54:04.483778Z", + "iopub.status.idle": "2026-11-18T23:54:04.823039Z", + "shell.execute_reply": "2026-11-18T23:54:04.822633Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
rows
customers60000
accounts80000
transactions2175765
merchants2000
devices60000
\n", + "
" + ], + "text/plain": [ + " rows\n", + "customers 60000\n", + "accounts 80000\n", + "transactions 2175765\n", + "merchants 2000\n", + "devices 60000" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countmeanstdmin35%50%90%99%max
spend_30d80000.0341.71200.00.00.0122.9784.63058.5168530.7
\n", + "
" + ], + "text/plain": [ + " count mean std min 35% 50% 90% 99% max\n", + "spend_30d 80000.0 341.7 1200.0 0.0 0.0 122.9 784.6 3058.5 168530.7" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N_CUSTOMERS = int(N_ACCOUNTS * 0.75)\n", + "N_MERCHANTS = 2_000\n", + "DRIFT_DAY = 215\n", + "\n", + "merchants = pd.DataFrame({\n", + " \"merchant_id\": np.arange(N_MERCHANTS),\n", + " \"avg_ticket\": rng.lognormal(3.6, 0.7, N_MERCHANTS).round(2),\n", + " \"is_online\": (rng.random(N_MERCHANTS) < 0.4).astype(float),\n", + "})\n", + "premium = (merchants.avg_ticket > merchants.avg_ticket.quantile(0.9)).to_numpy()\n", + "premium_merchants = {\n", + " \"early\": merchants.merchant_id[premium & (merchants.is_online == 0)].to_numpy(),\n", + " \"late\": merchants.merchant_id[premium & (merchants.is_online == 1)].to_numpy(),\n", + "}\n", + "everyday_merchants = merchants.merchant_id[~premium].to_numpy()\n", + "\n", + "customers = pd.DataFrame({\n", + " \"customer_id\": np.arange(N_CUSTOMERS),\n", + " \"customer_age_years\": rng.integers(18, 85, N_CUSTOMERS).astype(float),\n", + " \"tenure_days\": rng.gamma(3.0, 400, N_CUSTOMERS).round(),\n", + " \"income_band\": rng.integers(1, 6, N_CUSTOMERS).astype(float),\n", + "})\n", + "devices = pd.DataFrame({\n", + " \"device_id\": np.arange(N_CUSTOMERS),\n", + " \"is_mobile\": (rng.random(N_CUSTOMERS) < 0.7).astype(float),\n", + " \"device_age_days\": rng.gamma(3.0, 200, N_CUSTOMERS).round(),\n", + "})\n", + "\n", + "\n", + "def simulate_accounts(account_ids, anchors):\n", + " n = len(account_ids)\n", + " owner = rng.integers(0, N_CUSTOMERS, n)\n", + " income = customers.income_band.to_numpy()[owner]\n", + " segment = rng.choice([\"dormant\", \"regular\", \"high\"], n, p=[0.35, 0.64, 0.01])\n", + " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", + " rate = rng.lognormal(-1.3, 0.5, n)\n", + " amount_scale = rng.lognormal(3.3, 0.4, n) * (0.7 + 0.15 * income) * np.where(segment == \"high\", 8.0, 1.0)\n", + " premium_share = np.where(segment == \"high\", 0.5, 0.05)\n", + " momentum = np.where(segment == \"dormant\", 0.0, rng.lognormal(0, 0.6, n))\n", + " quiet_days = np.where(segment == \"dormant\", rng.uniform(12, 30, n), 10.0)\n", + "\n", + " windows = [(rng.poisson(rate * (HISTORY_DAYS - 10)), np.full(n, float(HISTORY_DAYS)), quiet_days),\n", + " (rng.poisson(rate * momentum * 10), np.full(n, 10.0), np.zeros(n))]\n", + " parts = []\n", + " for counts, oldest, newest in windows:\n", + " i = np.repeat(np.arange(n), counts)\n", + " use_premium = rng.random(len(i)) < premium_share[i]\n", + " premium_pick = np.where(late[i], rng.choice(premium_merchants[\"late\"], len(i)), rng.choice(premium_merchants[\"early\"], len(i)))\n", + " merchant = np.where(use_premium, premium_pick, rng.choice(everyday_merchants, len(i)))\n", + " parts.append(pd.DataFrame({\n", + " \"account_id\": account_ids[i], \"merchant_id\": merchant, \"device_id\": owner[i],\n", + " \"timestamp\": anchors.values[i] - pd.to_timedelta(rng.uniform(newest[i], oldest[i]), unit=\"D\"),\n", + " \"amount\": (amount_scale[i] * rng.lognormal(0, 0.6, len(i)) * np.where(use_premium, 3.0, 1.0)).round(2),\n", + " \"hour_of_day\": rng.normal(14, 4, len(i)).clip(0, 23).round(),\n", + " }))\n", + " transaction_frame = pd.concat(parts, ignore_index=True).sort_values(\"timestamp\", ignore_index=True)\n", + " transaction_frame[\"timestamp\"] = transaction_frame.timestamp.dt.floor(\"s\")\n", + "\n", + " future_spend = rng.poisson(rate * momentum * 30) * amount_scale * (1 + 2 * premium_share) * rng.lognormal(0, 0.3, n)\n", + " account_frame = pd.DataFrame({\n", + " \"account_id\": account_ids, \"customer_id\": owner,\n", + " \"account_age_days\": rng.gamma(3.0, 300, n).round(),\n", + " \"credit_limit\": (rng.lognormal(8.0, 0.5, n) * (0.6 + 0.2 * income) * np.where(segment == \"high\", 2.0, 1.0)).round(-2),\n", + " })\n", + " label_frame = pd.DataFrame({\"account_id\": account_ids, \"timestamp\": anchors, \"spend_30d\": future_spend.round(2)})\n", + " return account_frame, transaction_frame, label_frame\n", + "\n", + "\n", + "history_anchors = pd.Timestamp(START) + pd.to_timedelta(rng.integers(60, 365, N_ACCOUNTS), unit=\"D\")\n", + "accounts, transactions, labels = simulate_accounts(np.arange(N_ACCOUNTS), history_anchors)\n", + "transactions.insert(0, \"transaction_id\", np.arange(len(transactions)))\n", + "\n", + "display(pd.Series({\"customers\": len(customers), \"accounts\": len(accounts), \"transactions\": len(transactions),\n", + " \"merchants\": len(merchants), \"devices\": len(devices)}, name=\"rows\").to_frame())\n", + "display(labels.spend_30d.describe(percentiles=[0.35, 0.5, 0.9, 0.99]).round(1).to_frame().T)" + ] + }, + { + "cell_type": "markdown", + "id": "db4e4aa5", + "metadata": {}, + "source": [ + "## Build the relational data\n", + "\n", + "Declare column types and foreign keys. KumoRelational uses numerical and datetime features, and the sampler only uses transactions before each account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "04413e90", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:04.824638Z", + "iopub.status.busy": "2026-11-18T23:54:04.824573Z", + "iopub.status.idle": "2026-11-18T23:54:07.657828Z", + "shell.execute_reply": "2026-11-18T23:54:07.657300Z" + } + }, + "outputs": [], + "source": [ + "STYPES = {\n", + " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"tenure_days\": \"numerical\", \"income_band\": \"numerical\"},\n", + " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"account_age_days\": \"numerical\", \"credit_limit\": \"numerical\"},\n", + " \"merchants\": {\"merchant_id\": \"id\", \"avg_ticket\": \"numerical\", \"is_online\": \"numerical\"},\n", + " \"devices\": {\"device_id\": \"id\", \"is_mobile\": \"numerical\", \"device_age_days\": \"numerical\"},\n", + " \"transactions\": {\n", + " \"transaction_id\": \"id\", \"account_id\": \"id\", \"merchant_id\": \"id\", \"device_id\": \"id\",\n", + " \"timestamp\": \"datetime\", \"amount\": \"numerical\", \"hour_of_day\": \"numerical\",\n", + " },\n", + "}\n", + "RELATIONSHIPS = [\n", + " {\"left_table\": \"accounts\", \"left_column\": \"customer_id\", \"right_table\": \"customers\", \"right_column\": \"customer_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"account_id\", \"right_table\": \"accounts\", \"right_column\": \"account_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"merchant_id\", \"right_table\": \"merchants\", \"right_column\": \"merchant_id\"},\n", + " {\"left_table\": \"transactions\", \"left_column\": \"device_id\", \"right_table\": \"devices\", \"right_column\": \"device_id\"},\n", + "]\n", + "TASK_LINK = {\"task_column\": \"account_id\", \"table\": \"accounts\", \"table_column\": \"account_id\"}\n", + "\n", + "frames = {\"customers\": customers, \"accounts\": accounts, \"merchants\": merchants, \"devices\": devices, \"transactions\": transactions}\n", + "data = sdm.RelationalData(\n", + " tables={name: sdm.TableTensor.from_pandas(frame, stypes=STYPES[name]) for name, frame in frames.items()},\n", + " relationships=RELATIONSHIPS,\n", + ")\n", + "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"spend_30d\": \"numerical\"})" + ] + }, + { + "cell_type": "markdown", + "id": "1befa33b", + "metadata": {}, + "source": [ + "Merchant spend levels sit two hops from an account, through its transactions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ed41df02", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:07.659027Z", + "iopub.status.busy": "2026-11-18T23:54:07.658935Z", + "iopub.status.idle": "2026-11-18T23:54:08.364138Z", + "shell.execute_reply": "2026-11-18T23:54:08.363485Z" + } + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "customers\n", + "\n", + "customers\n", + "\n", + "customer_id: id\n", + "customer_age_years: numerical\n", + "tenure_days: numerical\n", + "income_band: numerical\n", + "\n", + "\n", + "\n", + "accounts\n", + "\n", + "accounts\n", + "\n", + "account_id: id\n", + "customer_id: id\n", + "account_age_days: numerical\n", + "credit_limit: numerical\n", + "\n", + "\n", + "\n", + "accounts--customers\n", + "\n", + " customer_id <> customer_id \n", + "\n", + "\n", + "\n", + "merchants\n", + "\n", + "merchants\n", + "\n", + "merchant_id: id\n", + "avg_ticket: numerical\n", + "is_online: numerical\n", + "\n", + "\n", + "\n", + "devices\n", + "\n", + "devices\n", + "\n", + "device_id: id\n", + "is_mobile: numerical\n", + "device_age_days: numerical\n", + "\n", + "\n", + "\n", + "transactions\n", + "\n", + "transactions\n", + "\n", + "transaction_id: id\n", + "account_id: id\n", + "merchant_id: id\n", + "device_id: id\n", + "timestamp: datetime\n", + "amount: numerical\n", + "hour_of_day: numerical\n", + "\n", + "\n", + "\n", + "transactions--accounts\n", + "\n", + " account_id <> account_id \n", + "\n", + "\n", + "\n", + "transactions--merchants\n", + "\n", + " merchant_id <> merchant_id \n", + "\n", + "\n", + "\n", + "transactions--devices\n", + "\n", + " device_id <> device_id \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.to_graphviz()" + ] + }, + { + "cell_type": "markdown", + "id": "84938429", + "metadata": {}, + "source": [ + "## Split accounts by time\n", + "\n", + "Context pool: before day 270. Validation: days 270 to 309. Test: day 310 onward. Spend bands (zero, low, mid, top) come from the pool's distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eb0d6472", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:08.365661Z", + "iopub.status.busy": "2026-11-18T23:54:08.365572Z", + "iopub.status.idle": "2026-11-18T23:54:08.373401Z", + "shell.execute_reply": "2026-11-18T23:54:08.373077Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
accountszero_spend_sharetop_band_accounts
context pool549090.3611099
validation105910.363208
test145000.365281
\n", + "
" + ], + "text/plain": [ + " accounts zero_spend_share top_band_accounts\n", + "context pool 54909 0.361 1099\n", + "validation 10591 0.363 208\n", + "test 14500 0.365 281" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", + "spend = labels.spend_30d.to_numpy()\n", + "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", + "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", + "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", + "y_val, y_test = spend[val_rows], spend[test_rows]\n", + "\n", + "pool_spend = spend[pool_rows]\n", + "top_cut = np.quantile(pool_spend, 1 - TOP_SHARE)\n", + "band = np.digitize(spend, [1e-9, np.median(pool_spend[pool_spend > 0]), top_cut])\n", + "display(pd.DataFrame({\n", + " \"accounts\": [len(pool_rows), len(val_rows), len(test_rows)],\n", + " \"zero_spend_share\": [np.mean(spend[r] == 0) for r in (pool_rows, val_rows, test_rows)],\n", + " \"top_band_accounts\": [np.sum(band[r] == 3) for r in (pool_rows, val_rows, test_rows)],\n", + "}, index=[\"context pool\", \"validation\", \"test\"]).round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "84d906be", + "metadata": {}, + "source": [ + "## Define the helpers\n", + "\n", + "`score_contexts` fits the model on each context, scores the queries and averages each quantile across contexts; one context is an ensemble of one. It keeps the `QUANTILES` grid from the model's 999 outputs. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html).\n", + "\n", + "Metrics: overall MAE, MAE on the top band, Spearman correlation, and top-band capture, which is the share of actual top spenders ranked in the predicted top `TOP_SHARE`. The top-band metrics are most telling when a few accounts drive most of the value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3991dfed", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:08.374615Z", + "iopub.status.busy": "2026-11-18T23:54:08.374552Z", + "iopub.status.idle": "2026-11-18T23:54:09.406956Z", + "shell.execute_reply": "2026-11-18T23:54:09.406389Z" + } + }, + "outputs": [], + "source": [ + "model = sdm.models.KumoRelational(device=device)\n", + "evaluation_query = task_table[torch.as_tensor(np.concatenate([val_rows, test_rows]))].drop_columns(\"spend_30d\")\n", + "QUANTILE_COLUMNS = [f\"q{round(q * 1000):03d}\" for q in QUANTILES]\n", + "\n", + "\n", + "def score_contexts(contexts, num_neighbors=FIRST_HOP_NEIGHBORS, temporal_strategy=\"uniform\", batch_size=5_000):\n", + " options = dict(task_link=TASK_LINK, num_neighbors=[num_neighbors, SECOND_HOP_NEIGHBORS],\n", + " task_time_column=\"timestamp\", temporal_strategy=temporal_strategy)\n", + " members = []\n", + " for context_rows in contexts:\n", + " torch.manual_seed(SEED)\n", + " context, related = sampler(task_table[torch.as_tensor(context_rows)], **options).to(device)\n", + " model.fit(x=context.drop_columns(\"spend_30d\"), y=context[\"spend_30d\"], related_tables=related)\n", + " batches = []\n", + " for query_batch in evaluation_query.split(batch_size, -2):\n", + " out = model.predict(*sampler(query_batch, **options).to(device))\n", + " columns = list(out.columns[sdm.Stype.numerical])\n", + " batches.append(out.numerical[:, [columns.index(c) for c in QUANTILE_COLUMNS]].float().cpu().numpy())\n", + " members.append(np.concatenate(batches))\n", + " grid = np.mean(members, axis=0)\n", + " return grid[: len(val_rows)], grid[len(val_rows):]\n", + "\n", + "\n", + "def capture(y_true, prediction):\n", + " k = max(1, round(len(y_true) * TOP_SHARE))\n", + " return len(set(np.argsort(-prediction)[:k]) & set(np.argsort(-y_true)[:k])) / k\n", + "\n", + "\n", + "def metrics(y_true, grid, quantile):\n", + " prediction = grid[:, QUANTILES.index(quantile)]\n", + " top = y_true >= top_cut\n", + " return {\n", + " \"mae\": np.abs(prediction - y_true).mean(),\n", + " \"top_band_mae\": np.abs(prediction[top] - y_true[top]).mean(),\n", + " \"spearman\": spearmanr(prediction, y_true).statistic,\n", + " \"top_band_capture\": capture(y_true, prediction),\n", + " \"quantile\": quantile,\n", + " }\n", + "\n", + "\n", + "def best_quantile(y_true, grid, under_cost=1.0):\n", + " errors = grid - y_true[:, None]\n", + " loss = np.where(errors < 0, -under_cost * errors, errors).mean(axis=0)\n", + " return QUANTILES[int(np.argmin(loss))]\n", + "\n", + "\n", + "def tuned_val_mae(val_grid):\n", + " return metrics(y_val, val_grid, best_quantile(y_val, val_grid))[\"mae\"]\n", + "\n", + "\n", + "stages = {}" + ] + }, + { + "cell_type": "markdown", + "id": "3660ef5e", + "metadata": {}, + "source": [ + "## Score the baseline\n", + "\n", + "Use a random context at the natural target distribution and report the median (q0.50)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b423b5c9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:09.408103Z", + "iopub.status.busy": "2026-11-18T23:54:09.408033Z", + "iopub.status.idle": "2026-11-18T23:54:46.534605Z", + "shell.execute_reply": "2026-11-18T23:54:46.534158Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top-band accounts in the baseline context: 113 of 5000\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maetop_band_maespearmantop_band_capturequantile
Baseline, median255.4563310.6470.630.4070.5
\n", + "
" + ], + "text/plain": [ + " mae top_band_mae spearman top_band_capture quantile\n", + "Baseline, median 255.456 3310.647 0.63 0.407 0.5" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "baseline_context = rng.choice(pool_rows, BASELINE_CONTEXT_SIZE, replace=False)\n", + "stages[\"Baseline\"] = score_contexts([baseline_context])\n", + "print(f\"Top-band accounts in the baseline context: {np.sum(band[baseline_context] == 3)} of {BASELINE_CONTEXT_SIZE}\")\n", + "display(pd.DataFrame({\"Baseline, median\": metrics(y_test, stages[\"Baseline\"][1], 0.5)}).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "54bd64fe", + "metadata": {}, + "source": [ + "## Strategy 1: compose the context\n", + "\n", + "Compare a larger random context, equal rows per spend band, every top-band account plus random fill, and the top band repeated `TOP_REPEAT` times. Each candidate is judged at its own validation-tuned quantile, since composition shifts the predicted distribution. This is most useful when the target is skewed, as a random context then holds few high-value examples." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "651212df", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:54:46.536270Z", + "iopub.status.busy": "2026-11-18T23:54:46.536183Z", + "iopub.status.idle": "2026-11-18T23:58:20.968395Z", + "shell.execute_reply": "2026-11-18T23:58:20.965537Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tuned_quantilevalidation_maevalidation_mae_at_medianvalidation_top_band_mae
Natural, 5,000 rows0.45266.009268.2553625.974
Natural, 10,000 rows0.50255.096255.0963680.133
Stratified by band0.40260.854280.9123366.546
All top + natural0.40258.651273.5113341.648
Top x3 + natural0.25283.501366.0243661.430
\n", + "
" + ], + "text/plain": [ + " tuned_quantile validation_mae \\\n", + "Natural, 5,000 rows 0.45 266.009 \n", + "Natural, 10,000 rows 0.50 255.096 \n", + "Stratified by band 0.40 260.854 \n", + "All top + natural 0.40 258.651 \n", + "Top x3 + natural 0.25 283.501 \n", + "\n", + " validation_mae_at_median validation_top_band_mae \n", + "Natural, 5,000 rows 268.255 3625.974 \n", + "Natural, 10,000 rows 255.096 3680.133 \n", + "Stratified by band 280.912 3366.546 \n", + "All top + natural 273.511 3341.648 \n", + "Top x3 + natural 366.024 3661.430 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected context design: Natural, 10,000 rows\n" + ] + } + ], + "source": [ + "def natural(rows, size):\n", + " return rng.choice(rows, size, replace=False)\n", + "\n", + "\n", + "def stratified(rows):\n", + " return np.concatenate([rng.choice(rows[band[rows] == b], min(ROWS_PER_BAND, np.sum(band[rows] == b)), replace=False) for b in range(4)])\n", + "\n", + "\n", + "def top_plus_natural(rows, repeat):\n", + " top_rows = rows[band[rows] == 3]\n", + " return np.concatenate([np.tile(top_rows, repeat), natural(rows[band[rows] < 3], LARGE_CONTEXT_SIZE - repeat * len(top_rows))])\n", + "\n", + "\n", + "context_designs = {\n", + " f\"Natural, {BASELINE_CONTEXT_SIZE:,} rows\": lambda rows: natural(rows, BASELINE_CONTEXT_SIZE),\n", + " f\"Natural, {LARGE_CONTEXT_SIZE:,} rows\": lambda rows: natural(rows, LARGE_CONTEXT_SIZE),\n", + " \"Stratified by band\": stratified,\n", + " \"All top + natural\": lambda rows: top_plus_natural(rows, 1),\n", + " f\"Top x{TOP_REPEAT} + natural\": lambda rows: top_plus_natural(rows, TOP_REPEAT),\n", + "}\n", + "design_scores = {f\"Natural, {BASELINE_CONTEXT_SIZE:,} rows\": stages[\"Baseline\"]}\n", + "for name, design in context_designs.items():\n", + " if name not in design_scores:\n", + " design_scores[name] = score_contexts([design(pool_rows)])\n", + "\n", + "comparison = pd.DataFrame({\n", + " name: {\n", + " \"tuned_quantile\": best_quantile(y_val, val_grid),\n", + " \"validation_mae\": tuned_val_mae(val_grid),\n", + " \"validation_mae_at_median\": metrics(y_val, val_grid, 0.5)[\"mae\"],\n", + " \"validation_top_band_mae\": metrics(y_val, val_grid, best_quantile(y_val, val_grid))[\"top_band_mae\"],\n", + " }\n", + " for name, (val_grid, _) in design_scores.items()\n", + "}).T\n", + "best_design = comparison.validation_mae.idxmin()\n", + "stages[\"+ Context composition\"] = design_scores[best_design]\n", + "display(comparison.round(3))\n", + "print(\"Selected context design:\", best_design)" + ] + }, + { + "cell_type": "markdown", + "id": "aabbb0e1", + "metadata": {}, + "source": [ + "Oversampling the tail raises the whole predicted distribution, so it needs a lower quantile, and its error at the median grows. Whether it helps after re-tuning depends on how well features already identify the tail.\n", + "\n", + "## Strategy 2: ensemble contexts\n", + "\n", + "Draw `NUM_ESTIMATORS` contexts with the selected design and average each quantile across members. See [ensembling](https://nvidia.github.io/structured-data-models/icl.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "be6bc210", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-18T23:58:20.982008Z", + "iopub.status.busy": "2026-11-18T23:58:20.981452Z", + "iopub.status.idle": "2026-11-19T00:02:36.593778Z", + "shell.execute_reply": "2026-11-19T00:02:36.593216Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation MAE per member: [256.9 253.1 274. 257.3 253.7]\n", + "Validation MAE of the ensemble: 242.9\n" + ] + } + ], + "source": [ + "design = context_designs[best_design]\n", + "member_scores = [score_contexts([design(pool_rows)]) for _ in range(NUM_ESTIMATORS)]\n", + "stages[\"+ Context ensemble\"] = tuple(np.mean([member[i] for member in member_scores], axis=0) for i in range(2))\n", + "print(\"Validation MAE per member:\", np.round([tuned_val_mae(val_grid) for val_grid, _ in member_scores], 1))\n", + "print(f\"Validation MAE of the ensemble: {tuned_val_mae(stages['+ Context ensemble'][0]):.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8bb518e8", + "metadata": {}, + "source": [ + "## Strategy 3: tune sampling\n", + "\n", + "Test each change on a single context and keep it only if validation MAE, at its tuned quantile, improves:\n", + "\n", + "* **Recent accounts:** apply the selected design to the pool's last 90 days.\n", + "* **Most recent transactions:** `temporal_strategy=\"last\"` instead of a uniform sample.\n", + "* **More neighbors:** more first-hop transactions per account." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "90e94a4b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:02:36.595863Z", + "iopub.status.busy": "2026-11-19T00:02:36.595750Z", + "iopub.status.idle": "2026-11-19T00:06:57.038682Z", + "shell.execute_reply": "2026-11-19T00:06:57.036395Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
changerecent_accountsnum_neighborstemporal_strategyvalidation_mae
0Current settingsFalse8uniform255.434
1Recent accountsTrue8uniform257.371
2Most recent transactionsFalse8last190.550
316 neighborsFalse16last182.426
\n", + "
" + ], + "text/plain": [ + " change recent_accounts num_neighbors temporal_strategy \\\n", + "0 Current settings False 8 uniform \n", + "1 Recent accounts True 8 uniform \n", + "2 Most recent transactions False 8 last \n", + "3 16 neighbors False 16 last \n", + "\n", + " validation_mae \n", + "0 255.434 \n", + "1 257.371 \n", + "2 190.550 \n", + "3 182.426 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected sampling settings: {'use_recent': False, 'num_neighbors': 16, 'temporal_strategy': 'last'}\n" + ] + } + ], + "source": [ + "recent_rows = pool_rows[observation_day[pool_rows] >= VALIDATION_START_DAY - RECENT_CONTEXT_DAYS]\n", + "\n", + "\n", + "def candidate_context(use_recent):\n", + " return design(recent_rows if use_recent else pool_rows)\n", + "\n", + "\n", + "trials = []\n", + "\n", + "\n", + "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", + " val_grid, _ = score_contexts([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", + " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", + " \"temporal_strategy\": temporal_strategy, \"validation_mae\": tuned_val_mae(val_grid)})\n", + " return trials[-1][\"validation_mae\"]\n", + "\n", + "\n", + "settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", + "best_mae = try_settings(\"Current settings\", **settings)\n", + "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", + " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", + "]:\n", + " trial_mae = try_settings(change, **{**settings, **update})\n", + " if trial_mae < best_mae:\n", + " settings, best_mae = {**settings, **update}, trial_mae\n", + "\n", + "display(pd.DataFrame(trials).round(3))\n", + "print(\"Selected sampling settings:\", settings)" + ] + }, + { + "cell_type": "markdown", + "id": "0aa43f72", + "metadata": {}, + "source": [ + "Rebuild the ensemble with the selected settings." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "adf28a60", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:06:57.054163Z", + "iopub.status.busy": "2026-11-19T00:06:57.054069Z", + "iopub.status.idle": "2026-11-19T00:16:04.219889Z", + "shell.execute_reply": "2026-11-19T00:16:04.212067Z" + } + }, + "outputs": [], + "source": [ + "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", + "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", + "stages[\"+ Sampling settings\"] = score_contexts(final_contexts, **sampling_options)" + ] + }, + { + "cell_type": "markdown", + "id": "805cc62c", + "metadata": {}, + "source": [ + "## Strategy 4: choose the output quantile per configuration\n", + "\n", + "Pick the quantile with the lowest validation MAE for every stage. Re-pick whenever the context or sampling changes. The choice matters more for skewed targets, where the median and the best quantile can sit far apart." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ee0f322b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:16:04.237760Z", + "iopub.status.busy": "2026-11-19T00:16:04.237152Z", + "iopub.status.idle": "2026-11-19T00:16:04.309458Z", + "shell.execute_reply": "2026-11-19T00:16:04.309114Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mae_quantile
Baseline0.45
+ Context composition0.50
+ Context ensemble0.45
+ Sampling settings0.50
\n", + "
" + ], + "text/plain": [ + " mae_quantile\n", + "Baseline 0.45\n", + "+ Context composition 0.50\n", + "+ Context ensemble 0.45\n", + "+ Sampling settings 0.50" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tuned_quantiles = {name: best_quantile(y_val, val_grid) for name, (val_grid, _) in stages.items()}\n", + "display(pd.Series(tuned_quantiles, name=\"mae_quantile\").to_frame())" + ] + }, + { + "cell_type": "markdown", + "id": "ac998c1d", + "metadata": {}, + "source": [ + "When under-forecasting costs more than over-forecasting, for example in liquidity or limit planning, choose the quantile that minimizes that asymmetric cost instead. Compare both on the final configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a0226264", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:16:04.315195Z", + "iopub.status.busy": "2026-11-19T00:16:04.315116Z", + "iopub.status.idle": "2026-11-19T00:16:04.344928Z", + "shell.execute_reply": "2026-11-19T00:16:04.344568Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maetop_band_maespearmantop_band_capturequantileasymmetric_costunder_forecast_share
Min MAE176.8412284.1720.8430.5860.5441.8980.565
Under-forecast cost x3220.3912297.8350.8300.5900.7356.5720.249
\n", + "
" + ], + "text/plain": [ + " mae top_band_mae spearman top_band_capture \\\n", + "Min MAE 176.841 2284.172 0.843 0.586 \n", + "Under-forecast cost x3 220.391 2297.835 0.830 0.590 \n", + "\n", + " quantile asymmetric_cost under_forecast_share \n", + "Min MAE 0.5 441.898 0.565 \n", + "Under-forecast cost x3 0.7 356.572 0.249 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "final_val, final_test = stages[\"+ Sampling settings\"]\n", + "cost_quantile = best_quantile(y_val, final_val, under_cost=UNDER_PREDICTION_COST)\n", + "operating_points = {}\n", + "for name, quantile in [(\"Min MAE\", tuned_quantiles[\"+ Sampling settings\"]), (f\"Under-forecast cost x{UNDER_PREDICTION_COST:g}\", cost_quantile)]:\n", + " prediction = final_test[:, QUANTILES.index(quantile)]\n", + " errors = prediction - y_test\n", + " operating_points[name] = {\n", + " **metrics(y_test, final_test, quantile),\n", + " \"asymmetric_cost\": np.where(errors < 0, -UNDER_PREDICTION_COST * errors, errors).mean(),\n", + " \"under_forecast_share\": np.mean(errors < 0),\n", + " }\n", + "display(pd.DataFrame(operating_points).T.round(3))" + ] + }, + { + "cell_type": "markdown", + "id": "775cb401", + "metadata": {}, + "source": [ + "## Compare the lift\n", + "\n", + "Each row adds one strategy to the row above and, after the first row, reports its own tuned quantile. All rows use the same test accounts, and the table is saved to the run directory. **Demonstration only.**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f6dc0fe0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:16:04.346097Z", + "iopub.status.busy": "2026-11-19T00:16:04.346042Z", + "iopub.status.idle": "2026-11-19T00:16:04.427820Z", + "shell.execute_reply": "2026-11-19T00:16:04.427491Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
maetop_band_maespearmantop_band_capturequantile
Baseline, median255.4563310.6470.6300.4070.50
Baseline, tuned quantile254.2183250.4940.6250.4100.45
+ Context composition244.4803111.3310.6420.4100.50
+ Context ensemble237.2143058.1420.7440.4280.45
+ Sampling settings176.8412284.1720.8430.5860.50
\n", + "
" + ], + "text/plain": [ + " mae top_band_mae spearman top_band_capture \\\n", + "Baseline, median 255.456 3310.647 0.630 0.407 \n", + "Baseline, tuned quantile 254.218 3250.494 0.625 0.410 \n", + "+ Context composition 244.480 3111.331 0.642 0.410 \n", + "+ Context ensemble 237.214 3058.142 0.744 0.428 \n", + "+ Sampling settings 176.841 2284.172 0.843 0.586 \n", + "\n", + " quantile \n", + "Baseline, median 0.50 \n", + "Baseline, tuned quantile 0.45 \n", + "+ Context composition 0.50 \n", + "+ Context ensemble 0.45 \n", + "+ Sampling settings 0.50 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAE: 255.5 -> 176.8; top-band MAE: 3310.6 -> 2284.2; Spearman: 0.630 -> 0.843\n" + ] + } + ], + "source": [ + "lift_rows = {\"Baseline, median\": metrics(y_test, stages[\"Baseline\"][1], 0.5)}\n", + "for name, (_, test_grid) in stages.items():\n", + " lift_rows[\"Baseline, tuned quantile\" if name == \"Baseline\" else name] = metrics(y_test, test_grid, tuned_quantiles[name])\n", + "summary = pd.DataFrame(lift_rows).T\n", + "summary.to_csv(run_dir / \"lift_summary.csv\")\n", + "display(summary.round(3))\n", + "first, last = summary.iloc[0], summary.iloc[-1]\n", + "print(f\"MAE: {first.mae:.1f} -> {last.mae:.1f}; top-band MAE: {first.top_band_mae:.1f} -> {last.top_band_mae:.1f}; \"\n", + " f\"Spearman: {first.spearman:.3f} -> {last.spearman:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "766ead17", + "metadata": {}, + "source": [ + "Plot the headline metrics by stage." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3158e49b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:16:04.429193Z", + "iopub.status.busy": "2026-11-19T00:16:04.429129Z", + "iopub.status.idle": "2026-11-19T00:16:04.787291Z", + "shell.execute_reply": "2026-11-19T00:16:04.786946Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "panels = [(\"mae\", \"MAE (lower is better)\"), (\"top_band_mae\", \"Top-band MAE (lower is better)\"), (\"spearman\", \"Spearman correlation\")]\n", + "fig, axes = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)\n", + "for axis, (column, title) in zip(axes, panels):\n", + " values = summary[column].to_numpy()[::-1]\n", + " axis.barh(summary.index[::-1], values, color=\"#2a78d6\", height=0.6)\n", + " for position, value in enumerate(values):\n", + " axis.text(value * 1.01, position, f\"{value:,.2f}\" if column == \"spearman\" else f\"{value:,.0f}\", va=\"center\", fontsize=9, color=\"#52514e\")\n", + " axis.set_xlim(0, max(values) * 1.18 if column != \"spearman\" else 1)\n", + " axis.set_title(title, loc=\"left\", fontsize=11)\n", + " axis.spines[[\"top\", \"right\"]].set_visible(False)\n", + " axis.grid(axis=\"x\", color=\"#e4e3df\", linewidth=0.8)\n", + " axis.set_axisbelow(True)\n", + "fig.suptitle(\"Test-set lift by strategy (synthetic data, demonstration only)\", x=0.01, ha=\"left\", fontsize=12)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "95ece53a", + "metadata": {}, + "source": [ + "## Clean up\n", + "\n", + "Set `CLEANUP = True` to delete this run's directory." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cec08f14", + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T00:16:04.788793Z", + "iopub.status.busy": "2026-11-19T00:16:04.788712Z", + "iopub.status.idle": "2026-11-19T00:16:04.791551Z", + "shell.execute_reply": "2026-11-19T00:16:04.791154Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-73ej8kxe.\n" + ] + } + ], + "source": [ + "if CLEANUP:\n", + " workspace.cleanup()\n", + "print(\"Removed this run's files.\" if CLEANUP else f\"Results retained in {run_dir}.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 840d76e9a34336b18260457dd0735aa513b45ca0 Mon Sep 17 00:00:00 2001 From: aliu65803 <102877337+aliu65803@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:13:24 -0600 Subject: [PATCH 4/5] Update local_structured_data_models_imbalanced_classification_tuning.ipynb --- ...tructured_data_models_imbalanced_classification_tuning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb index 7dcbde703..58562e3a6 100644 --- a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb +++ b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb @@ -7,7 +7,7 @@ "source": [ "# Improve KumoRelational performance on imbalanced data\n", "\n", - "KumoRelational, a relational foundation model (RFM), predicts from labeled in-context examples. With a rare positive class, a random context holds few positives and the model under-predicts that class at the default 0.5 cutoff. This notebook tests four fixes and measures the lift of each, using fraud detection as the example: which accounts will be confirmed as fraud within 30 days?\n", + "KumoRelational, a relational foundation model (RFM), predicts from labeled in-context examples. This notebook demonstrates four strategies to improve performance and measures the lift of each, using an imbalanced classes fraud detection use case as the example: which accounts will be confirmed as fraud within 30 days?\n", "\n", "| Strategy | What changes |\n", "| --- | --- |\n", From 62e0ee8f1ba3492fced0e0c7a8d0cb12332d8096 Mon Sep 17 00:00:00 2001 From: aliu65803 Date: Wed, 18 Nov 2026 20:04:31 -0600 Subject: [PATCH 5/5] Address review on KumoRelational tuning notebooks - Add a 30-day label-maturity gap between the context, validation and test windows so every label is known before the window it tunes. - Give accounts an open date (and customers a join date) and filter them in the sampler, so sibling accounts never expose later records. - Reuse context rows across sampling-only trials, reuse ensemble members for the sampling stage, and name the stage when the recent pool wins. - Score only validation accounts in tuning trials, validate the fraud repetition budget, and report when no cutoff meets the precision target. - Regression: switch premium merchants by transaction date and define top-band capture against the same band as top-band MAE. - Note that pyg-lib is needed on GPU hosts too, and re-execute both notebooks (classification now uses 100k accounts at 0.7% fraud). Co-Authored-By: Claude Opus 5.5 --- ...els_imbalanced_classification_tuning.ipynb | 691 +++++++++++------- ...ctured_data_models_regression_tuning.ipynb | 609 +++++++-------- 2 files changed, 743 insertions(+), 557 deletions(-) diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb index 58562e3a6..6bd4280c9 100644 --- a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb +++ b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_imbalanced_classification_tuning.ipynb @@ -26,14 +26,21 @@ "source": [ "## Install and configure\n", "\n", - "On CPU, sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." + "Sampling runs on CPU even when the model uses a GPU, so it always needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." ] }, { "cell_type": "code", "execution_count": 1, "id": "ceb339d5", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:29.509845Z", + "iopub.status.busy": "2026-11-19T01:48:29.509726Z", + "iopub.status.idle": "2026-11-19T01:48:30.347347Z", + "shell.execute_reply": "2026-11-19T01:48:30.346745Z" + } + }, "outputs": [], "source": [ "%pip install structured-data-models pandas pyarrow scikit-learn matplotlib graphviz" @@ -53,15 +60,23 @@ "cell_type": "code", "execution_count": 2, "id": "36dfda2d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:30.348994Z", + "iopub.status.busy": "2026-11-19T01:48:30.348870Z", + "iopub.status.idle": "2026-11-19T01:48:30.351487Z", + "shell.execute_reply": "2026-11-19T01:48:30.350968Z" + } + }, "outputs": [], "source": [ "SEED = 7\n", - "N_ACCOUNTS = 80_000\n", - "FRAUD_RATE = 0.005\n", + "N_ACCOUNTS = 100_000\n", + "FRAUD_RATE = 0.007\n", "START = \"2026-01-01\"\n", "HISTORY_DAYS = 90\n", - "VALIDATION_START_DAY = 270\n", + "HORIZON_DAYS = 30\n", + "VALIDATION_START_DAY = 250\n", "TEST_START_DAY = 310\n", "\n", "BASELINE_CONTEXT_SIZE = 5_000\n", @@ -91,13 +106,20 @@ "cell_type": "code", "execution_count": 3, "id": "8a4739ef", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:30.352753Z", + "iopub.status.busy": "2026-11-19T01:48:30.352661Z", + "iopub.status.idle": "2026-11-19T01:48:32.970254Z", + "shell.execute_reply": "2026-11-19T01:48:32.969851Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-fqxhuh07\n" + "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-c36lf3ed\n" ] } ], @@ -129,14 +151,21 @@ "\n", "Run the next cell to create five tables: customers, accounts, transactions, merchants and devices. You can skim it; the workflow starts at **Build the relational data**.\n", "\n", - "Fraud accounts tend to show a burst of activity just before their observation date, often at high-risk merchants or on shared or emulated devices, and belong to newer customers. Some legitimate accounts look similar, and the fraud pattern drifts mid-year." + "Fraud accounts tend to show a burst of activity just before their observation date, often at high-risk merchants or on shared or emulated devices, and belong to newer customers. Some legitimate accounts look similar, and the fraud pattern drifts in early May. Accounts carry an open date and customers a join date, so the sampler can exclude records created after each observation date." ] }, { "cell_type": "code", "execution_count": 4, "id": "678a7276", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:32.971413Z", + "iopub.status.busy": "2026-11-19T01:48:32.971314Z", + "iopub.status.idle": "2026-11-19T01:48:33.348974Z", + "shell.execute_reply": "2026-11-19T01:48:33.348660Z" + } + }, "outputs": [ { "data": { @@ -165,15 +194,15 @@ " \n", " \n", " customers\n", - " 60000\n", + " 75000\n", " \n", " \n", " accounts\n", - " 80000\n", + " 100000\n", " \n", " \n", " transactions\n", - " 2257154\n", + " 2821422\n", " \n", " \n", " merchants\n", @@ -181,7 +210,7 @@ " \n", " \n", " devices\n", - " 61500\n", + " 76500\n", " \n", " \n", "\n", @@ -189,11 +218,11 @@ ], "text/plain": [ " rows\n", - "customers 60000\n", - "accounts 80000\n", - "transactions 2257154\n", + "customers 75000\n", + "accounts 100000\n", + "transactions 2821422\n", "merchants 2000\n", - "devices 61500" + "devices 76500" ] }, "metadata": {}, @@ -203,7 +232,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Fraud rate: 0.52% (about 1 in 193)\n" + "Fraud rate: 0.69% (about 1 in 145)\n" ] } ], @@ -211,7 +240,7 @@ "N_CUSTOMERS = int(N_ACCOUNTS * 0.75)\n", "N_MERCHANTS = 2_000\n", "N_SHARED_DEVICES = 1_500\n", - "DRIFT_DAY = 215\n", + "DRIFT_DAY = 120\n", "\n", "merchants = pd.DataFrame({\n", " \"merchant_id\": np.arange(N_MERCHANTS),\n", @@ -228,15 +257,14 @@ "customers = pd.DataFrame({\n", " \"customer_id\": np.arange(N_CUSTOMERS),\n", " \"customer_age_years\": rng.integers(18, 85, N_CUSTOMERS).astype(float),\n", - " \"tenure_days\": rng.gamma(3.0, 400, N_CUSTOMERS).round(),\n", + " \"joined_at\": pd.Timestamp(START) - pd.to_timedelta(rng.gamma(3.0, 400, N_CUSTOMERS).round(), unit=\"D\"),\n", " \"kyc_tier\": rng.integers(1, 4, N_CUSTOMERS).astype(float),\n", "})\n", "devices = pd.DataFrame({\n", " \"device_id\": np.arange(N_CUSTOMERS + N_SHARED_DEVICES),\n", " \"is_emulator\": np.r_[np.zeros(N_CUSTOMERS), (rng.random(N_SHARED_DEVICES) < 0.7)].astype(float),\n", - " \"device_age_days\": np.r_[rng.gamma(3.0, 200, N_CUSTOMERS), rng.gamma(1.0, 15, N_SHARED_DEVICES)].round(),\n", "})\n", - "recent_customers = customers.customer_id[customers.tenure_days < 180].to_numpy()\n", + "recent_customers = customers.customer_id[customers.joined_at > pd.Timestamp(START) - pd.Timedelta(days=180)].to_numpy()\n", "shared_devices = np.arange(N_CUSTOMERS, N_CUSTOMERS + N_SHARED_DEVICES)\n", "\n", "\n", @@ -270,7 +298,10 @@ " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", " account_frame = pd.DataFrame({\n", " \"account_id\": account_ids, \"customer_id\": owner,\n", - " \"account_age_days\": np.where(is_fraud, rng.gamma(2.0, 150, n), rng.gamma(3.0, 300, n)).round(),\n", + " \"opened_at\": np.maximum(\n", + " anchors - pd.to_timedelta(np.where(is_fraud, rng.gamma(2.0, 150, n), rng.gamma(3.0, 300, n)).round() + HISTORY_DAYS, unit=\"D\"),\n", + " customers.joined_at.to_numpy()[owner] + pd.Timedelta(days=1),\n", + " ),\n", " \"credit_limit\": rng.lognormal(8.0, 0.6, n).round(-2),\n", " })\n", " counts = rng.poisson(24, n) + 4\n", @@ -306,21 +337,28 @@ "source": [ "## Build the relational data\n", "\n", - "Declare column types and foreign keys. KumoRelational uses numerical and datetime features, and the sampler only uses transactions before each account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." + "Declare column types and foreign keys. KumoRelational uses numerical and datetime features. The sampler only uses transactions, accounts and customers dated before each observation date, so another account of the same customer opened later is excluded; merchant and device attributes are static. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." ] }, { "cell_type": "code", "execution_count": 5, "id": "fb9900ab", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:33.350152Z", + "iopub.status.busy": "2026-11-19T01:48:33.350101Z", + "iopub.status.idle": "2026-11-19T01:48:34.634192Z", + "shell.execute_reply": "2026-11-19T01:48:34.633708Z" + } + }, "outputs": [], "source": [ "STYPES = {\n", - " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"tenure_days\": \"numerical\", \"kyc_tier\": \"numerical\"},\n", - " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"account_age_days\": \"numerical\", \"credit_limit\": \"numerical\"},\n", + " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"joined_at\": \"datetime\", \"kyc_tier\": \"numerical\"},\n", + " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"opened_at\": \"datetime\", \"credit_limit\": \"numerical\"},\n", " \"merchants\": {\"merchant_id\": \"id\", \"risk_score\": \"numerical\", \"is_online\": \"numerical\", \"avg_ticket\": \"numerical\"},\n", - " \"devices\": {\"device_id\": \"id\", \"is_emulator\": \"numerical\", \"device_age_days\": \"numerical\"},\n", + " \"devices\": {\"device_id\": \"id\", \"is_emulator\": \"numerical\"},\n", " \"transactions\": {\n", " \"transaction_id\": \"id\", \"account_id\": \"id\", \"merchant_id\": \"id\", \"device_id\": \"id\", \"timestamp\": \"datetime\",\n", " \"amount\": \"numerical\", \"is_international\": \"numerical\", \"hour_of_day\": \"numerical\",\n", @@ -339,7 +377,7 @@ " tables={name: sdm.TableTensor.from_pandas(frame, stypes=STYPES[name]) for name, frame in frames.items()},\n", " relationships=RELATIONSHIPS,\n", ")\n", - "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\", \"accounts\": \"opened_at\", \"customers\": \"joined_at\"})\n", "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"is_fraud\": \"categorical\"})" ] }, @@ -355,7 +393,14 @@ "cell_type": "code", "execution_count": 6, "id": "2b4b84bf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:34.635386Z", + "iopub.status.busy": "2026-11-19T01:48:34.635285Z", + "iopub.status.idle": "2026-11-19T01:48:34.913391Z", + "shell.execute_reply": "2026-11-19T01:48:34.912962Z" + } + }, "outputs": [ { "data": { @@ -366,10 +411,10 @@ "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", "customers\n", @@ -378,19 +423,19 @@ "\n", "customer_id: id\n", "customer_age_years: numerical\n", - "tenure_days: numerical\n", - "kyc_tier: numerical\n", + "kyc_tier: numerical\n", + "joined_at: datetime\n", "\n", "\n", "\n", "accounts\n", - "\n", + "\n", "accounts\n", - "\n", - "account_id: id\n", - "customer_id: id\n", - "account_age_days: numerical\n", - "credit_limit: numerical\n", + "\n", + "account_id: id\n", + "customer_id: id\n", + "opened_at: datetime\n", + "credit_limit: numerical\n", "\n", "\n", "\n", @@ -401,62 +446,61 @@ "\n", "\n", "merchants\n", - "\n", - "merchants\n", - "\n", - "merchant_id: id\n", - "risk_score: numerical\n", - "is_online: numerical\n", - "avg_ticket: numerical\n", + "\n", + "merchants\n", + "\n", + "merchant_id: id\n", + "risk_score: numerical\n", + "is_online: numerical\n", + "avg_ticket: numerical\n", "\n", "\n", "\n", "devices\n", - "\n", - "devices\n", - "\n", - "device_id: id\n", - "is_emulator: numerical\n", - "device_age_days: numerical\n", + "\n", + "devices\n", + "\n", + "device_id: id\n", + "is_emulator: numerical\n", "\n", "\n", "\n", "transactions\n", - "\n", - "transactions\n", - "\n", - "transaction_id: id\n", - "account_id: id\n", - "merchant_id: id\n", - "device_id: id\n", - "timestamp: datetime\n", - "amount: numerical\n", - "is_international: numerical\n", - "hour_of_day: numerical\n", + "\n", + "transactions\n", + "\n", + "transaction_id: id\n", + "account_id: id\n", + "merchant_id: id\n", + "device_id: id\n", + "timestamp: datetime\n", + "amount: numerical\n", + "is_international: numerical\n", + "hour_of_day: numerical\n", "\n", "\n", "\n", "transactions--accounts\n", - "\n", - " account_id <> account_id \n", + "\n", + " account_id <> account_id \n", "\n", "\n", "\n", "transactions--merchants\n", - "\n", - " merchant_id <> merchant_id \n", + "\n", + " merchant_id <> merchant_id \n", "\n", "\n", "\n", "transactions--devices\n", - "\n", - " device_id <> device_id \n", + "\n", + " device_id <> device_id \n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -475,14 +519,21 @@ "source": [ "## Split accounts by time\n", "\n", - "Context pool: before day 270. Validation: days 270 to 309. Test: day 310 onward." + "Each label needs 30 days to mature, so each window ends 30 days before the next one starts: context pool before day 220, validation days 250 to 279, test from day 310. Settings are then fixed using only outcomes known before the windows they are applied to." ] }, { "cell_type": "code", "execution_count": 7, "id": "483b06b2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:34.914625Z", + "iopub.status.busy": "2026-11-19T01:48:34.914541Z", + "iopub.status.idle": "2026-11-19T01:48:34.919935Z", + "shell.execute_reply": "2026-11-19T01:48:34.919520Z" + } + }, "outputs": [ { "data": { @@ -512,18 +563,18 @@ " \n", "
\n", " context pool\n", - " 55219\n", - " 294\n", + " 52458\n", + " 352\n", "
\n", "
\n", " validation\n", - " 10464\n", - " 54\n", + " 9814\n", + " 67\n", "
\n", "
\n", " test\n", - " 14317\n", - " 66\n", + " 18022\n", + " 124\n", "
\n", "
\n", "\n", @@ -531,9 +582,9 @@ ], "text/plain": [ " accounts fraud_accounts\n", - "context pool 55219 294\n", - "validation 10464 54\n", - "test 14317 66" + "context pool 52458 352\n", + "validation 9814 67\n", + "test 18022 124" ] }, "metadata": {}, @@ -543,8 +594,8 @@ "source": [ "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", "is_fraud = labels.is_fraud.eq(\"fraud\").to_numpy()\n", - "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", - "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", + "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY - HORIZON_DAYS)\n", + "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY - HORIZON_DAYS))\n", "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", "fraud_pool = pool_rows[is_fraud[pool_rows]]\n", "legit_pool = pool_rows[~is_fraud[pool_rows]]\n", @@ -563,14 +614,21 @@ "source": [ "## Define the helpers\n", "\n", - "`score_contexts` fits the model on each context, scores the queries and averages the probabilities; one context is an ensemble of one. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html)." + "`score_contexts` fits the model on each context, scores the queries and averages the probabilities; `score_validation` scores only validation accounts for tuning trials; one context is an ensemble of one. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html)." ] }, { "cell_type": "code", "execution_count": 8, "id": "34c71ffd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:34.920976Z", + "iopub.status.busy": "2026-11-19T01:48:34.920919Z", + "iopub.status.idle": "2026-11-19T01:48:35.354644Z", + "shell.execute_reply": "2026-11-19T01:48:35.354258Z" + } + }, "outputs": [], "source": [ "model = sdm.models.KumoRelational(device=device)\n", @@ -597,6 +655,10 @@ " return probabilities[: len(val_rows)], probabilities[len(val_rows):]\n", "\n", "\n", + "def score_validation(contexts, **options):\n", + " return score_contexts(contexts, evaluation_query[: len(val_rows)], sampler, **options)\n", + "\n", + "\n", "def metrics(y_true, probability, threshold):\n", " flagged = probability >= threshold\n", " return {\n", @@ -636,13 +698,20 @@ "cell_type": "code", "execution_count": 9, "id": "4a25a0a8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:48:35.355812Z", + "iopub.status.busy": "2026-11-19T01:48:35.355749Z", + "iopub.status.idle": "2026-11-19T01:49:27.429778Z", + "shell.execute_reply": "2026-11-19T01:49:27.429198Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Fraud examples in the baseline context: 22 of 5000\n" + "Fraud examples in the baseline context: 44 of 5000\n" ] }, { @@ -677,11 +746,11 @@ " \n", "
\n", " Baseline\n", - " 0.287\n", - " 0.938\n", - " 0.714\n", - " 0.076\n", - " 0.137\n", + " 0.238\n", + " 0.907\n", + " 0.818\n", + " 0.073\n", + " 0.133\n", " 0.5\n", "
\n", "
\n", @@ -690,7 +759,7 @@ ], "text/plain": [ " average_precision auroc precision recall f1 threshold\n", - "Baseline 0.287 0.938 0.714 0.076 0.137 0.5" + "Baseline 0.238 0.907 0.818 0.073 0.133 0.5" ] }, "metadata": {}, @@ -721,7 +790,14 @@ "cell_type": "code", "execution_count": 10, "id": "bfe64ce3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:49:27.431452Z", + "iopub.status.busy": "2026-11-19T01:49:27.431351Z", + "iopub.status.idle": "2026-11-19T01:54:02.864755Z", + "shell.execute_reply": "2026-11-19T01:54:02.862761Z" + } + }, "outputs": [ { "data": { @@ -752,33 +828,33 @@ " \n", "
\n", " 1:1\n", - " 0.276\n", - " 0.963\n", - " 0.018\n", + " 0.376\n", + " 0.896\n", + " 0.048\n", "
\n", "
\n", " 1:5\n", - " 0.254\n", - " 0.704\n", - " 0.063\n", + " 0.363\n", + " 0.761\n", + " 0.079\n", "
\n", "
\n", " 1:20\n", - " 0.302\n", - " 0.407\n", - " 0.265\n", + " 0.406\n", + " 0.478\n", + " 0.288\n", "
\n", "
\n", " All fraud, 10,000 rows\n", - " 0.329\n", - " 0.463\n", - " 0.238\n", + " 0.387\n", + " 0.582\n", + " 0.177\n", "
\n", "
\n", " Fraud x10, 10,000 rows\n", - " 0.341\n", - " 0.537\n", - " 0.121\n", + " 0.227\n", + " 0.448\n", + " 0.164\n", "
\n", "
\n", "\n", @@ -786,18 +862,18 @@ ], "text/plain": [ " validation_average_precision \\\n", - "1:1 0.276 \n", - "1:5 0.254 \n", - "1:20 0.302 \n", - "All fraud, 10,000 rows 0.329 \n", - "Fraud x10, 10,000 rows 0.341 \n", + "1:1 0.376 \n", + "1:5 0.363 \n", + "1:20 0.406 \n", + "All fraud, 10,000 rows 0.387 \n", + "Fraud x10, 10,000 rows 0.227 \n", "\n", " validation_recall_at_0.5 validation_precision_at_0.5 \n", - "1:1 0.963 0.018 \n", - "1:5 0.704 0.063 \n", - "1:20 0.407 0.265 \n", - "All fraud, 10,000 rows 0.463 0.238 \n", - "Fraud x10, 10,000 rows 0.537 0.121 " + "1:1 0.896 0.048 \n", + "1:5 0.761 0.079 \n", + "1:20 0.478 0.288 \n", + "All fraud, 10,000 rows 0.582 0.177 \n", + "Fraud x10, 10,000 rows 0.448 0.164 " ] }, "metadata": {}, @@ -807,12 +883,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Selected context design: Fraud x10, 10,000 rows\n" + "Selected context design: 1:20\n" ] } ], "source": [ "n_fraud = len(fraud_pool)\n", + "if FRAUD_REPEAT * n_fraud >= LARGE_CONTEXT_SIZE:\n", + " raise ValueError(f\"FRAUD_REPEAT={FRAUD_REPEAT} needs {FRAUD_REPEAT * n_fraud:,} fraud rows, more than LARGE_CONTEXT_SIZE={LARGE_CONTEXT_SIZE:,}.\")\n", "context_designs = {\n", " \"1:1\": (1, n_fraud),\n", " \"1:5\": (1, 5 * n_fraud),\n", @@ -856,14 +934,21 @@ "cell_type": "code", "execution_count": 11, "id": "c99df08e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:54:02.879184Z", + "iopub.status.busy": "2026-11-19T01:54:02.879080Z", + "iopub.status.idle": "2026-11-19T01:58:56.336802Z", + "shell.execute_reply": "2026-11-19T01:58:56.334063Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Validation AP per member: [0.338 0.335 0.321 0.349 0.312]\n", - "Validation AP of the ensemble: 0.347\n" + "Validation AP per member: [0.362 0.402 0.402 0.382 0.385]\n", + "Validation AP of the ensemble: 0.423\n" ] } ], @@ -887,9 +972,9 @@ "\n", "## Strategy 3: tune sampling\n", "\n", - "Test each change on a single context and keep it only if validation average precision improves:\n", + "Test each change on the first ensemble member's context rows, so only the sampling setting changes, and keep it only if validation average precision improves:\n", "\n", - "* **Recent accounts:** build the context from the pool's last 90 days at the same class ratio. Draw both classes from that window, or the observation date leaks the label.\n", + "* **Recent accounts:** build the context from the pool's last 90 days at the same class ratio. That window holds fewer positives, so this trial changes context size too. Draw both classes from that window, or the observation date leaks the label.\n", "* **Most recent transactions:** `temporal_strategy=\"last\"` instead of a uniform sample.\n", "* **More neighbors:** more first-hop transactions per account." ] @@ -898,7 +983,14 @@ "cell_type": "code", "execution_count": 12, "id": "46692a91", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T01:58:56.352314Z", + "iopub.status.busy": "2026-11-19T01:58:56.351774Z", + "iopub.status.idle": "2026-11-19T02:00:14.894883Z", + "shell.execute_reply": "2026-11-19T02:00:14.892862Z" + } + }, "outputs": [ { "data": { @@ -922,7 +1014,8 @@ "
\n", " \n", " change\n", - " recent_accounts\n", + " context_rows\n", + " fraud_rows\n", " num_neighbors\n", " temporal_strategy\n", " validation_average_precision\n", @@ -932,51 +1025,55 @@ "
\n", " 0\n", " Current settings\n", - " False\n", + " 7392\n", + " 352\n", " 8\n", " uniform\n", - " 0.384\n", + " 0.362\n", "
\n", "
\n", " 1\n", " Recent accounts\n", - " True\n", + " 2877\n", + " 137\n", " 8\n", " uniform\n", - " 0.213\n", + " 0.392\n", "
\n", "
\n", " 2\n", " Most recent transactions\n", - " False\n", + " 2877\n", + " 137\n", " 8\n", " last\n", - " 0.469\n", + " 0.679\n", "
\n", "
\n", " 3\n", " 16 neighbors\n", - " False\n", + " 2877\n", + " 137\n", " 16\n", " last\n", - " 0.312\n", + " 0.609\n", "
\n", " \n", "\n", "" ], "text/plain": [ - " change recent_accounts num_neighbors temporal_strategy \\\n", - "0 Current settings False 8 uniform \n", - "1 Recent accounts True 8 uniform \n", - "2 Most recent transactions False 8 last \n", - "3 16 neighbors False 16 last \n", + " change context_rows fraud_rows num_neighbors \\\n", + "0 Current settings 7392 352 8 \n", + "1 Recent accounts 2877 137 8 \n", + "2 Most recent transactions 2877 137 8 \n", + "3 16 neighbors 2877 137 16 \n", "\n", - " validation_average_precision \n", - "0 0.384 \n", - "1 0.213 \n", - "2 0.469 \n", - "3 0.312 " + " temporal_strategy validation_average_precision \n", + "0 uniform 0.362 \n", + "1 uniform 0.392 \n", + "2 last 0.679 \n", + "3 last 0.609 " ] }, "metadata": {}, @@ -986,7 +1083,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Selected sampling settings: {'use_recent': False, 'num_neighbors': 8, 'temporal_strategy': 'last'}\n" + "Selected sampling settings: {'use_recent': True, 'num_neighbors': 8, 'temporal_strategy': 'last'}\n" ] } ], @@ -996,24 +1093,30 @@ "legit_per_fraud = n_legit / n_fraud\n", "\n", "\n", - "def candidate_context(use_recent):\n", - " if use_recent:\n", - " return compose_context(recent_fraud, recent_legit, round(legit_per_fraud * len(recent_fraud)), fraud_repeat)\n", - " return compose_context(fraud_pool, legit_pool, n_legit, fraud_repeat)\n", + "def recent_context():\n", + " return compose_context(recent_fraud, recent_legit, round(legit_per_fraud * len(recent_fraud)), fraud_repeat)\n", "\n", "\n", + "trial_contexts = {False: ensemble_contexts[0], True: recent_context()}\n", "trials = []\n", "\n", "\n", - "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", - " trial_val, _ = score_evaluation([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", - " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", - " \"temporal_strategy\": temporal_strategy, \"validation_average_precision\": average_precision_score(y_val, trial_val)})\n", + "def record(change, use_recent, num_neighbors, temporal_strategy, val_prob):\n", + " context = trial_contexts[use_recent]\n", + " trials.append({\"change\": change, \"context_rows\": len(context), \"fraud_rows\": int(is_fraud[context].sum()),\n", + " \"num_neighbors\": num_neighbors, \"temporal_strategy\": temporal_strategy,\n", + " \"validation_average_precision\": average_precision_score(y_val, val_prob)})\n", " return trials[-1][\"validation_average_precision\"]\n", "\n", "\n", - "settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", - "best_ap = try_settings(\"Current settings\", **settings)\n", + "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", + " val_prob = score_validation([trial_contexts[use_recent]], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", + " return record(change, use_recent, num_neighbors, temporal_strategy, val_prob)\n", + "\n", + "\n", + "default_settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", + "settings = dict(default_settings)\n", + "best_ap = record(\"Current settings\", **settings, val_prob=member_scores[0][0])\n", "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", "]:\n", @@ -1030,14 +1133,21 @@ "id": "1a9c6baa", "metadata": {}, "source": [ - "Rebuild the ensemble with the selected settings." + "Score the ensemble with the selected settings. It keeps the same members unless the recent pool was selected, which the stage name then states." ] }, { "cell_type": "code", "execution_count": 13, "id": "afe53b51", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:00:14.912762Z", + "iopub.status.busy": "2026-11-19T02:00:14.912459Z", + "iopub.status.idle": "2026-11-19T02:03:56.628518Z", + "shell.execute_reply": "2026-11-19T02:03:56.626128Z" + } + }, "outputs": [ { "data": { @@ -1067,34 +1177,40 @@ " \n", "
\n", " Baseline\n", - " 0.291\n", - " 0.167\n", + " 0.213\n", + " 0.104\n", "
\n", "
\n", " + Rebalanced context\n", - " 0.341\n", - " 0.537\n", + " 0.406\n", + " 0.478\n", "
\n", "
\n", " + Context ensemble\n", - " 0.347\n", - " 0.593\n", + " 0.423\n", + " 0.507\n", "
\n", "
\n", - " + Sampling settings\n", - " 0.599\n", - " 0.111\n", + " + Sampling settings (recent pool)\n", + " 0.682\n", + " 0.642\n", "
\n", "
\n", "\n", "" ], "text/plain": [ - " validation_average_precision validation_recall_at_0.5\n", - "Baseline 0.291 0.167\n", - "+ Rebalanced context 0.341 0.537\n", - "+ Context ensemble 0.347 0.593\n", - "+ Sampling settings 0.599 0.111" + " validation_average_precision \\\n", + "Baseline 0.213 \n", + "+ Rebalanced context 0.406 \n", + "+ Context ensemble 0.423 \n", + "+ Sampling settings (recent pool) 0.682 \n", + "\n", + " validation_recall_at_0.5 \n", + "Baseline 0.104 \n", + "+ Rebalanced context 0.478 \n", + "+ Context ensemble 0.507 \n", + "+ Sampling settings (recent pool) 0.642 " ] }, "metadata": {}, @@ -1102,10 +1218,18 @@ } ], "source": [ - "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", - "final_val, final_test = score_evaluation(final_contexts, **sampling_options)\n", - "stages[\"+ Sampling settings\"] = (final_val, final_test)\n", + "if settings[\"use_recent\"]:\n", + " final_stage = \"+ Sampling settings (recent pool)\"\n", + " final_contexts = [trial_contexts[True]] + [recent_context() for _ in range(NUM_ESTIMATORS - 1)]\n", + "else:\n", + " final_stage = \"+ Sampling settings\"\n", + " final_contexts = ensemble_contexts\n", + "if settings == default_settings:\n", + " final_val, final_test = ensemble_val, ensemble_test\n", + "else:\n", + " final_val, final_test = score_evaluation(final_contexts, **sampling_options)\n", + "stages[final_stage] = (final_val, final_test)\n", "display(pd.DataFrame({\n", " \"validation_average_precision\": {name: average_precision_score(y_val, val_prob) for name, (val_prob, _) in stages.items()},\n", " \"validation_recall_at_0.5\": {name: recall_score(y_val, val_prob >= DEFAULT_THRESHOLD) for name, (val_prob, _) in stages.items()},\n", @@ -1128,7 +1252,14 @@ "cell_type": "code", "execution_count": 14, "id": "ebd64c4d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:03:56.666515Z", + "iopub.status.busy": "2026-11-19T02:03:56.664691Z", + "iopub.status.idle": "2026-11-19T02:03:56.729774Z", + "shell.execute_reply": "2026-11-19T02:03:56.729418Z" + } + }, "outputs": [ { "data": { @@ -1157,30 +1288,30 @@ " \n", "
\n", " Baseline\n", - " 0.390\n", + " 0.161\n", "
\n", "
\n", " + Rebalanced context\n", - " 0.970\n", + " 0.720\n", "
\n", "
\n", " + Context ensemble\n", - " 0.838\n", + " 0.567\n", "
\n", "
\n", - " + Sampling settings\n", - " 0.060\n", + " + Sampling settings (recent pool)\n", + " 0.563\n", "
\n", "
\n", "\n", "" ], "text/plain": [ - " max_f1_threshold\n", - "Baseline 0.390\n", - "+ Rebalanced context 0.970\n", - "+ Context ensemble 0.838\n", - "+ Sampling settings 0.060" + " max_f1_threshold\n", + "Baseline 0.161\n", + "+ Rebalanced context 0.720\n", + "+ Context ensemble 0.567\n", + "+ Sampling settings (recent pool) 0.563" ] }, "metadata": {}, @@ -1206,7 +1337,14 @@ "cell_type": "code", "execution_count": 15, "id": "fb8f055e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:03:56.733302Z", + "iopub.status.busy": "2026-11-19T02:03:56.733239Z", + "iopub.status.idle": "2026-11-19T02:03:56.832244Z", + "shell.execute_reply": "2026-11-19T02:03:56.831881Z" + } + }, "outputs": [ { "data": { @@ -1240,21 +1378,21 @@ " \n", "
\n", " Max F1\n", - " 0.553\n", - " 0.961\n", - " 0.610\n", - " 0.545\n", - " 0.576\n", - " 0.060\n", + " 0.705\n", + " 0.969\n", + " 0.845\n", + " 0.573\n", + " 0.683\n", + " 0.563\n", "
\n", "
\n", " Precision >= 50%\n", - " 0.553\n", - " 0.961\n", - " 0.413\n", - " 0.652\n", - " 0.506\n", - " 0.039\n", + " 0.705\n", + " 0.969\n", + " 0.707\n", + " 0.661\n", + " 0.683\n", + " 0.389\n", "
\n", "
\n", "\n", @@ -1262,12 +1400,12 @@ ], "text/plain": [ " average_precision auroc precision recall f1 \\\n", - "Max F1 0.553 0.961 0.610 0.545 0.576 \n", - "Precision >= 50% 0.553 0.961 0.413 0.652 0.506 \n", + "Max F1 0.705 0.969 0.845 0.573 0.683 \n", + "Precision >= 50% 0.705 0.969 0.707 0.661 0.683 \n", "\n", " threshold \n", - "Max F1 0.060 \n", - "Precision >= 50% 0.039 " + "Max F1 0.563 \n", + "Precision >= 50% 0.389 " ] }, "metadata": {}, @@ -1277,12 +1415,13 @@ "source": [ "val_precision, val_recall, candidate_thresholds = precision_recall_curve(y_val, final_val)\n", "meets_precision = np.flatnonzero(val_precision[:-1] >= TARGET_PRECISION)\n", - "precision_threshold = (candidate_thresholds[meets_precision[np.argmax(val_recall[:-1][meets_precision])]]\n", - " if len(meets_precision) else tuned_thresholds[\"+ Sampling settings\"])\n", - "display(pd.DataFrame({\n", - " \"Max F1\": metrics(y_test, final_test, tuned_thresholds[\"+ Sampling settings\"]),\n", - " f\"Precision >= {TARGET_PRECISION:.0%}\": metrics(y_test, final_test, precision_threshold),\n", - "}).T.round(3))" + "operating_points = {\"Max F1\": metrics(y_test, final_test, tuned_thresholds[final_stage])}\n", + "if len(meets_precision):\n", + " precision_threshold = candidate_thresholds[meets_precision[np.argmax(val_recall[:-1][meets_precision])]]\n", + " operating_points[f\"Precision >= {TARGET_PRECISION:.0%}\"] = metrics(y_test, final_test, precision_threshold)\n", + "else:\n", + " print(f\"No validation cutoff reaches {TARGET_PRECISION:.0%} precision; showing max F1 only.\")\n", + "display(pd.DataFrame(operating_points).T.round(3))" ] }, { @@ -1299,7 +1438,14 @@ "cell_type": "code", "execution_count": 16, "id": "e66b8256", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:03:56.833391Z", + "iopub.status.busy": "2026-11-19T02:03:56.833328Z", + "iopub.status.idle": "2026-11-19T02:03:56.990710Z", + "shell.execute_reply": "2026-11-19T02:03:56.990347Z" + } + }, "outputs": [ { "data": { @@ -1333,67 +1479,67 @@ " \n", "
\n", " Baseline, 0.5 cutoff\n", - " 0.287\n", - " 0.938\n", - " 0.714\n", - " 0.076\n", - " 0.137\n", + " 0.238\n", + " 0.907\n", + " 0.818\n", + " 0.073\n", + " 0.133\n", " 0.500\n", "
\n", "
\n", " Baseline, tuned cutoff\n", - " 0.287\n", - " 0.938\n", - " 0.625\n", - " 0.152\n", - " 0.244\n", - " 0.390\n", + " 0.238\n", + " 0.907\n", + " 0.223\n", + " 0.355\n", + " 0.274\n", + " 0.161\n", "
\n", "
\n", " + Rebalanced context\n", - " 0.322\n", - " 0.956\n", - " 0.647\n", - " 0.167\n", - " 0.265\n", - " 0.970\n", + " 0.319\n", + " 0.929\n", + " 0.828\n", + " 0.194\n", + " 0.314\n", + " 0.720\n", "
\n", "
\n", " + Context ensemble\n", - " 0.392\n", - " 0.954\n", - " 0.458\n", - " 0.409\n", - " 0.432\n", - " 0.838\n", + " 0.394\n", + " 0.943\n", + " 0.374\n", + " 0.444\n", + " 0.406\n", + " 0.567\n", "
\n", "
\n", - " + Sampling settings\n", - " 0.553\n", - " 0.961\n", - " 0.610\n", - " 0.545\n", - " 0.576\n", - " 0.060\n", + " + Sampling settings (recent pool)\n", + " 0.705\n", + " 0.969\n", + " 0.845\n", + " 0.573\n", + " 0.683\n", + " 0.563\n", "
\n", "
\n", "\n", "" ], "text/plain": [ - " average_precision auroc precision recall f1 \\\n", - "Baseline, 0.5 cutoff 0.287 0.938 0.714 0.076 0.137 \n", - "Baseline, tuned cutoff 0.287 0.938 0.625 0.152 0.244 \n", - "+ Rebalanced context 0.322 0.956 0.647 0.167 0.265 \n", - "+ Context ensemble 0.392 0.954 0.458 0.409 0.432 \n", - "+ Sampling settings 0.553 0.961 0.610 0.545 0.576 \n", + " average_precision auroc precision \\\n", + "Baseline, 0.5 cutoff 0.238 0.907 0.818 \n", + "Baseline, tuned cutoff 0.238 0.907 0.223 \n", + "+ Rebalanced context 0.319 0.929 0.828 \n", + "+ Context ensemble 0.394 0.943 0.374 \n", + "+ Sampling settings (recent pool) 0.705 0.969 0.845 \n", "\n", - " threshold \n", - "Baseline, 0.5 cutoff 0.500 \n", - "Baseline, tuned cutoff 0.390 \n", - "+ Rebalanced context 0.970 \n", - "+ Context ensemble 0.838 \n", - "+ Sampling settings 0.060 " + " recall f1 threshold \n", + "Baseline, 0.5 cutoff 0.073 0.133 0.500 \n", + "Baseline, tuned cutoff 0.355 0.274 0.161 \n", + "+ Rebalanced context 0.194 0.314 0.720 \n", + "+ Context ensemble 0.444 0.406 0.567 \n", + "+ Sampling settings (recent pool) 0.573 0.683 0.563 " ] }, "metadata": {}, @@ -1403,7 +1549,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average precision: 0.287 -> 0.553; recall: 0.076 -> 0.545; F1: 0.137 -> 0.576\n" + "Average precision: 0.238 -> 0.705; recall: 0.073 -> 0.573; F1: 0.133 -> 0.683\n" ] } ], @@ -1431,11 +1577,18 @@ "cell_type": "code", "execution_count": 17, "id": "86a4c153", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:03:56.992240Z", + "iopub.status.busy": "2026-11-19T02:03:56.992168Z", + "iopub.status.idle": "2026-11-19T02:03:57.343190Z", + "shell.execute_reply": "2026-11-19T02:03:57.342839Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1475,13 +1628,20 @@ "cell_type": "code", "execution_count": 18, "id": "b6d3ca27", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-11-19T02:03:57.345066Z", + "iopub.status.busy": "2026-11-19T02:03:57.344993Z", + "iopub.status.idle": "2026-11-19T02:03:57.346817Z", + "shell.execute_reply": "2026-11-19T02:03:57.346480Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-fqxhuh07.\n" + "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/fraud-context-tuning-c36lf3ed.\n" ] } ], @@ -1499,7 +1659,16 @@ "name": "python3" }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.13" } }, "nbformat": 4, diff --git a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb index 14e2a73d0..67b97fe27 100644 --- a/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb +++ b/examples/kumo-example-notebooks/structured-data-models/relational/cross-industry/notebooks/local_structured_data_models_regression_tuning.ipynb @@ -26,7 +26,7 @@ "source": [ "## Install and configure\n", "\n", - "On CPU, sampling also needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." + "Sampling runs on CPU even when the model uses a GPU, so it always needs a [pyg-lib wheel](https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html) matching your PyTorch version; the schema diagram needs [Graphviz](https://graphviz.org/download/). See [installation](https://nvidia.github.io/structured-data-models/install.html)." ] }, { @@ -35,10 +35,10 @@ "id": "52d2488b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:53:53.568174Z", - "iopub.status.busy": "2026-11-18T23:53:53.568075Z", - "iopub.status.idle": "2026-11-18T23:53:55.457414Z", - "shell.execute_reply": "2026-11-18T23:53:55.456554Z" + "iopub.execute_input": "2026-11-19T01:19:53.503325Z", + "iopub.status.busy": "2026-11-19T01:19:53.503159Z", + "iopub.status.idle": "2026-11-19T01:19:55.288108Z", + "shell.execute_reply": "2026-11-19T01:19:55.287403Z" } }, "outputs": [], @@ -62,10 +62,10 @@ "id": "20403f80", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:53:55.459494Z", - "iopub.status.busy": "2026-11-18T23:53:55.459342Z", - "iopub.status.idle": "2026-11-18T23:53:55.462506Z", - "shell.execute_reply": "2026-11-18T23:53:55.461996Z" + "iopub.execute_input": "2026-11-19T01:19:55.289522Z", + "iopub.status.busy": "2026-11-19T01:19:55.289404Z", + "iopub.status.idle": "2026-11-19T01:19:55.292092Z", + "shell.execute_reply": "2026-11-19T01:19:55.291455Z" } }, "outputs": [], @@ -74,7 +74,8 @@ "N_ACCOUNTS = 80_000\n", "START = \"2026-01-01\"\n", "HISTORY_DAYS = 90\n", - "VALIDATION_START_DAY = 270\n", + "HORIZON_DAYS = 30\n", + "VALIDATION_START_DAY = 250\n", "TEST_START_DAY = 310\n", "\n", "BASELINE_CONTEXT_SIZE = 5_000\n", @@ -108,10 +109,10 @@ "id": "14c39647", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:53:55.464269Z", - "iopub.status.busy": "2026-11-18T23:53:55.464144Z", - "iopub.status.idle": "2026-11-18T23:54:04.482493Z", - "shell.execute_reply": "2026-11-18T23:54:04.482015Z" + "iopub.execute_input": "2026-11-19T01:19:55.293153Z", + "iopub.status.busy": "2026-11-19T01:19:55.293065Z", + "iopub.status.idle": "2026-11-19T01:20:03.284724Z", + "shell.execute_reply": "2026-11-19T01:20:03.284237Z" } }, "outputs": [ @@ -119,7 +120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-73ej8kxe\n" + "Device: cpu | Results: /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-_zl0q29z\n" ] } ], @@ -151,7 +152,7 @@ "\n", "Run the next cell to create five tables: customers, accounts, transactions, merchants and devices. You can skim it; the workflow starts at **Build the relational data**.\n", "\n", - "About a third of accounts go quiet before their observation date and spend nothing in the next 30 days. About 1% are high spenders who shop at premium merchants. Future spend tracks each account's activity in its last 10 days, and high spenders move from in-store to online premium merchants mid-year." + "About a third of accounts go quiet before their observation date and spend nothing in the next 30 days. About 1% are high spenders who shop at premium merchants. Future spend tracks each account's activity in its last 10 days, and high spenders move from in-store to online premium merchants in late May. Accounts carry an open date, so the sampler can exclude accounts opened after each observation date." ] }, { @@ -160,10 +161,10 @@ "id": "3efd059e", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:04.483900Z", - "iopub.status.busy": "2026-11-18T23:54:04.483778Z", - "iopub.status.idle": "2026-11-18T23:54:04.823039Z", - "shell.execute_reply": "2026-11-18T23:54:04.822633Z" + "iopub.execute_input": "2026-11-19T01:20:03.285952Z", + "iopub.status.busy": "2026-11-19T01:20:03.285827Z", + "iopub.status.idle": "2026-11-19T01:20:03.675092Z", + "shell.execute_reply": "2026-11-19T01:20:03.674457Z" } }, "outputs": [ @@ -202,7 +203,7 @@ "
\n", "
\n", " transactions\n", - " 2175765\n", + " 2165327\n", "
\n", "
\n", " merchants\n", @@ -220,7 +221,7 @@ " rows\n", "customers 60000\n", "accounts 80000\n", - "transactions 2175765\n", + "transactions 2165327\n", "merchants 2000\n", "devices 60000" ] @@ -264,14 +265,14 @@ "
\n", " spend_30d\n", " 80000.0\n", - " 341.7\n", - " 1200.0\n", + " 347.3\n", + " 1213.0\n", " 0.0\n", " 0.0\n", - " 122.9\n", - " 784.6\n", - " 3058.5\n", - " 168530.7\n", + " 124.9\n", + " 789.6\n", + " 3120.9\n", + " 108651.6\n", "
\n", " \n", "\n", @@ -279,7 +280,7 @@ ], "text/plain": [ " count mean std min 35% 50% 90% 99% max\n", - "spend_30d 80000.0 341.7 1200.0 0.0 0.0 122.9 784.6 3058.5 168530.7" + "spend_30d 80000.0 347.3 1213.0 0.0 0.0 124.9 789.6 3120.9 108651.6" ] }, "metadata": {}, @@ -289,7 +290,7 @@ "source": [ "N_CUSTOMERS = int(N_ACCOUNTS * 0.75)\n", "N_MERCHANTS = 2_000\n", - "DRIFT_DAY = 215\n", + "DRIFT_DAY = 150\n", "\n", "merchants = pd.DataFrame({\n", " \"merchant_id\": np.arange(N_MERCHANTS),\n", @@ -306,13 +307,11 @@ "customers = pd.DataFrame({\n", " \"customer_id\": np.arange(N_CUSTOMERS),\n", " \"customer_age_years\": rng.integers(18, 85, N_CUSTOMERS).astype(float),\n", - " \"tenure_days\": rng.gamma(3.0, 400, N_CUSTOMERS).round(),\n", " \"income_band\": rng.integers(1, 6, N_CUSTOMERS).astype(float),\n", "})\n", "devices = pd.DataFrame({\n", " \"device_id\": np.arange(N_CUSTOMERS),\n", " \"is_mobile\": (rng.random(N_CUSTOMERS) < 0.7).astype(float),\n", - " \"device_age_days\": rng.gamma(3.0, 200, N_CUSTOMERS).round(),\n", "})\n", "\n", "\n", @@ -321,7 +320,6 @@ " owner = rng.integers(0, N_CUSTOMERS, n)\n", " income = customers.income_band.to_numpy()[owner]\n", " segment = rng.choice([\"dormant\", \"regular\", \"high\"], n, p=[0.35, 0.64, 0.01])\n", - " late = (anchors - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", " rate = rng.lognormal(-1.3, 0.5, n)\n", " amount_scale = rng.lognormal(3.3, 0.4, n) * (0.7 + 0.15 * income) * np.where(segment == \"high\", 8.0, 1.0)\n", " premium_share = np.where(segment == \"high\", 0.5, 0.05)\n", @@ -333,12 +331,13 @@ " parts = []\n", " for counts, oldest, newest in windows:\n", " i = np.repeat(np.arange(n), counts)\n", + " timestamp = anchors.values[i] - pd.to_timedelta(rng.uniform(newest[i], oldest[i]), unit=\"D\")\n", + " after_switch = (timestamp - pd.Timestamp(START)).days.to_numpy() >= DRIFT_DAY\n", " use_premium = rng.random(len(i)) < premium_share[i]\n", - " premium_pick = np.where(late[i], rng.choice(premium_merchants[\"late\"], len(i)), rng.choice(premium_merchants[\"early\"], len(i)))\n", + " premium_pick = np.where(after_switch, rng.choice(premium_merchants[\"late\"], len(i)), rng.choice(premium_merchants[\"early\"], len(i)))\n", " merchant = np.where(use_premium, premium_pick, rng.choice(everyday_merchants, len(i)))\n", " parts.append(pd.DataFrame({\n", - " \"account_id\": account_ids[i], \"merchant_id\": merchant, \"device_id\": owner[i],\n", - " \"timestamp\": anchors.values[i] - pd.to_timedelta(rng.uniform(newest[i], oldest[i]), unit=\"D\"),\n", + " \"account_id\": account_ids[i], \"merchant_id\": merchant, \"device_id\": owner[i], \"timestamp\": timestamp,\n", " \"amount\": (amount_scale[i] * rng.lognormal(0, 0.6, len(i)) * np.where(use_premium, 3.0, 1.0)).round(2),\n", " \"hour_of_day\": rng.normal(14, 4, len(i)).clip(0, 23).round(),\n", " }))\n", @@ -348,7 +347,7 @@ " future_spend = rng.poisson(rate * momentum * 30) * amount_scale * (1 + 2 * premium_share) * rng.lognormal(0, 0.3, n)\n", " account_frame = pd.DataFrame({\n", " \"account_id\": account_ids, \"customer_id\": owner,\n", - " \"account_age_days\": rng.gamma(3.0, 300, n).round(),\n", + " \"opened_at\": anchors - pd.to_timedelta(rng.gamma(3.0, 300, n).round() + HISTORY_DAYS, unit=\"D\"),\n", " \"credit_limit\": (rng.lognormal(8.0, 0.5, n) * (0.6 + 0.2 * income) * np.where(segment == \"high\", 2.0, 1.0)).round(-2),\n", " })\n", " label_frame = pd.DataFrame({\"account_id\": account_ids, \"timestamp\": anchors, \"spend_30d\": future_spend.round(2)})\n", @@ -371,7 +370,7 @@ "source": [ "## Build the relational data\n", "\n", - "Declare column types and foreign keys. KumoRelational uses numerical and datetime features, and the sampler only uses transactions before each account's observation date. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." + "Declare column types and foreign keys. KumoRelational uses numerical and datetime features. The sampler only uses transactions and accounts dated before each observation date, so another account of the same customer opened later is excluded; customer, merchant and device attributes are static. See [RelationalData](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalData.html)." ] }, { @@ -380,19 +379,19 @@ "id": "04413e90", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:04.824638Z", - "iopub.status.busy": "2026-11-18T23:54:04.824573Z", - "iopub.status.idle": "2026-11-18T23:54:07.657828Z", - "shell.execute_reply": "2026-11-18T23:54:07.657300Z" + "iopub.execute_input": "2026-11-19T01:20:03.676174Z", + "iopub.status.busy": "2026-11-19T01:20:03.676103Z", + "iopub.status.idle": "2026-11-19T01:20:05.872017Z", + "shell.execute_reply": "2026-11-19T01:20:05.871626Z" } }, "outputs": [], "source": [ "STYPES = {\n", - " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"tenure_days\": \"numerical\", \"income_band\": \"numerical\"},\n", - " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"account_age_days\": \"numerical\", \"credit_limit\": \"numerical\"},\n", + " \"customers\": {\"customer_id\": \"id\", \"customer_age_years\": \"numerical\", \"income_band\": \"numerical\"},\n", + " \"accounts\": {\"account_id\": \"id\", \"customer_id\": \"id\", \"opened_at\": \"datetime\", \"credit_limit\": \"numerical\"},\n", " \"merchants\": {\"merchant_id\": \"id\", \"avg_ticket\": \"numerical\", \"is_online\": \"numerical\"},\n", - " \"devices\": {\"device_id\": \"id\", \"is_mobile\": \"numerical\", \"device_age_days\": \"numerical\"},\n", + " \"devices\": {\"device_id\": \"id\", \"is_mobile\": \"numerical\"},\n", " \"transactions\": {\n", " \"transaction_id\": \"id\", \"account_id\": \"id\", \"merchant_id\": \"id\", \"device_id\": \"id\",\n", " \"timestamp\": \"datetime\", \"amount\": \"numerical\", \"hour_of_day\": \"numerical\",\n", @@ -411,7 +410,7 @@ " tables={name: sdm.TableTensor.from_pandas(frame, stypes=STYPES[name]) for name, frame in frames.items()},\n", " relationships=RELATIONSHIPS,\n", ")\n", - "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\"})\n", + "sampler = data.sampler(time_columns={\"transactions\": \"timestamp\", \"accounts\": \"opened_at\"})\n", "task_table = sdm.TableTensor.from_pandas(labels, stypes={\"account_id\": \"id\", \"timestamp\": \"datetime\", \"spend_30d\": \"numerical\"})" ] }, @@ -429,10 +428,10 @@ "id": "ed41df02", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:07.659027Z", - "iopub.status.busy": "2026-11-18T23:54:07.658935Z", - "iopub.status.idle": "2026-11-18T23:54:08.364138Z", - "shell.execute_reply": "2026-11-18T23:54:08.363485Z" + "iopub.execute_input": "2026-11-19T01:20:05.873429Z", + "iopub.status.busy": "2026-11-19T01:20:05.873296Z", + "iopub.status.idle": "2026-11-19T01:20:06.340477Z", + "shell.execute_reply": "2026-11-19T01:20:06.340011Z" } }, "outputs": [ @@ -445,95 +444,93 @@ "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", "customers\n", - "\n", - "customers\n", - "\n", - "customer_id: id\n", - "customer_age_years: numerical\n", - "tenure_days: numerical\n", + "\n", + "customers\n", + "\n", + "customer_id: id\n", + "customer_age_years: numerical\n", "income_band: numerical\n", "\n", "\n", "\n", "accounts\n", - "\n", - "accounts\n", - "\n", - "account_id: id\n", - "customer_id: id\n", - "account_age_days: numerical\n", - "credit_limit: numerical\n", + "\n", + "accounts\n", + "\n", + "account_id: id\n", + "customer_id: id\n", + "opened_at: datetime\n", + "credit_limit: numerical\n", "\n", "\n", "\n", "accounts--customers\n", - "\n", - " customer_id <> customer_id \n", + "\n", + " customer_id <> customer_id \n", "\n", "\n", "\n", "merchants\n", - "\n", - "merchants\n", - "\n", - "merchant_id: id\n", - "avg_ticket: numerical\n", - "is_online: numerical\n", + "\n", + "merchants\n", + "\n", + "merchant_id: id\n", + "avg_ticket: numerical\n", + "is_online: numerical\n", "\n", "\n", "\n", "devices\n", - "\n", - "devices\n", - "\n", - "device_id: id\n", - "is_mobile: numerical\n", - "device_age_days: numerical\n", + "\n", + "devices\n", + "\n", + "device_id: id\n", + "is_mobile: numerical\n", "\n", "\n", "\n", "transactions\n", - "\n", - "transactions\n", - "\n", - "transaction_id: id\n", - "account_id: id\n", - "merchant_id: id\n", - "device_id: id\n", - "timestamp: datetime\n", - "amount: numerical\n", - "hour_of_day: numerical\n", + "\n", + "transactions\n", + "\n", + "transaction_id: id\n", + "account_id: id\n", + "merchant_id: id\n", + "device_id: id\n", + "timestamp: datetime\n", + "amount: numerical\n", + "hour_of_day: numerical\n", "\n", "\n", "\n", "transactions--accounts\n", - "\n", - " account_id <> account_id \n", + "\n", + " account_id <> account_id \n", "\n", "\n", "\n", "transactions--merchants\n", - "\n", - " merchant_id <> merchant_id \n", + "\n", + " merchant_id <> merchant_id \n", "\n", "\n", "\n", "transactions--devices\n", - "\n", - " device_id <> device_id \n", + "\n", + " device_id <> device_id \n", "\n", "\n", "\n" ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -552,7 +549,7 @@ "source": [ "## Split accounts by time\n", "\n", - "Context pool: before day 270. Validation: days 270 to 309. Test: day 310 onward. Spend bands (zero, low, mid, top) come from the pool's distribution." + "Each label needs 30 days to mature, so each window ends 30 days before the next one starts: context pool before day 220, validation days 250 to 279, test from day 310. Settings are then fixed using only outcomes known before the windows they are applied to. Spend bands (zero, low, mid, top) come from the pool's distribution." ] }, { @@ -561,10 +558,10 @@ "id": "eb0d6472", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:08.365661Z", - "iopub.status.busy": "2026-11-18T23:54:08.365572Z", - "iopub.status.idle": "2026-11-18T23:54:08.373401Z", - "shell.execute_reply": "2026-11-18T23:54:08.373077Z" + "iopub.execute_input": "2026-11-19T01:20:06.341913Z", + "iopub.status.busy": "2026-11-19T01:20:06.341826Z", + "iopub.status.idle": "2026-11-19T01:20:06.349020Z", + "shell.execute_reply": "2026-11-19T01:20:06.348674Z" } }, "outputs": [ @@ -597,21 +594,21 @@ " \n", "
\n", " context pool\n", - " 54909\n", - " 0.361\n", - " 1099\n", + " 41927\n", + " 0.359\n", + " 839\n", "
\n", "
\n", " validation\n", - " 10591\n", - " 0.363\n", - " 208\n", + " 7902\n", + " 0.364\n", + " 179\n", "
\n", "
\n", " test\n", - " 14500\n", - " 0.365\n", - " 281\n", + " 14322\n", + " 0.355\n", + " 288\n", "
\n", "
\n", "\n", @@ -619,9 +616,9 @@ ], "text/plain": [ " accounts zero_spend_share top_band_accounts\n", - "context pool 54909 0.361 1099\n", - "validation 10591 0.363 208\n", - "test 14500 0.365 281" + "context pool 41927 0.359 839\n", + "validation 7902 0.364 179\n", + "test 14322 0.355 288" ] }, "metadata": {}, @@ -631,8 +628,8 @@ "source": [ "observation_day = (labels.timestamp - pd.Timestamp(START)).dt.days.to_numpy()\n", "spend = labels.spend_30d.to_numpy()\n", - "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY)\n", - "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY))\n", + "pool_rows = np.flatnonzero(observation_day < VALIDATION_START_DAY - HORIZON_DAYS)\n", + "val_rows = np.flatnonzero((observation_day >= VALIDATION_START_DAY) & (observation_day < TEST_START_DAY - HORIZON_DAYS))\n", "test_rows = np.flatnonzero(observation_day >= TEST_START_DAY)\n", "y_val, y_test = spend[val_rows], spend[test_rows]\n", "\n", @@ -653,9 +650,9 @@ "source": [ "## Define the helpers\n", "\n", - "`score_contexts` fits the model on each context, scores the queries and averages each quantile across contexts; one context is an ensemble of one. It keeps the `QUANTILES` grid from the model's 999 outputs. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html).\n", + "`score_contexts` fits the model on each context, scores the queries and averages each quantile across contexts; `score_validation` scores only validation accounts for tuning trials; one context is an ensemble of one. It keeps the `QUANTILES` grid from the model's 999 outputs. Sampling covers two hops: `num_neighbors` transactions per account, then each transaction's merchant and device, plus up to `SECOND_HOP_NEIGHBORS` accounts per customer. See [RelationalSampler](https://nvidia.github.io/structured-data-models/api/generated/sdm.relational.RelationalSampler.html).\n", "\n", - "Metrics: overall MAE, MAE on the top band, Spearman correlation, and top-band capture, which is the share of actual top spenders ranked in the predicted top `TOP_SHARE`. The top-band metrics are most telling when a few accounts drive most of the value." + "Metrics: overall MAE, MAE on the top band, Spearman correlation, and top-band capture: the share of actual top-band accounts ranked in the predicted top k, where k is the number of top-band accounts. The top-band metrics are most telling when a few accounts drive most of the value." ] }, { @@ -664,10 +661,10 @@ "id": "3991dfed", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:08.374615Z", - "iopub.status.busy": "2026-11-18T23:54:08.374552Z", - "iopub.status.idle": "2026-11-18T23:54:09.406956Z", - "shell.execute_reply": "2026-11-18T23:54:09.406389Z" + "iopub.execute_input": "2026-11-19T01:20:06.350051Z", + "iopub.status.busy": "2026-11-19T01:20:06.349986Z", + "iopub.status.idle": "2026-11-19T01:20:07.311089Z", + "shell.execute_reply": "2026-11-19T01:20:07.310569Z" } }, "outputs": [], @@ -677,7 +674,7 @@ "QUANTILE_COLUMNS = [f\"q{round(q * 1000):03d}\" for q in QUANTILES]\n", "\n", "\n", - "def score_contexts(contexts, num_neighbors=FIRST_HOP_NEIGHBORS, temporal_strategy=\"uniform\", batch_size=5_000):\n", + "def predict_grid(contexts, query, num_neighbors=FIRST_HOP_NEIGHBORS, temporal_strategy=\"uniform\", batch_size=5_000):\n", " options = dict(task_link=TASK_LINK, num_neighbors=[num_neighbors, SECOND_HOP_NEIGHBORS],\n", " task_time_column=\"timestamp\", temporal_strategy=temporal_strategy)\n", " members = []\n", @@ -686,18 +683,27 @@ " context, related = sampler(task_table[torch.as_tensor(context_rows)], **options).to(device)\n", " model.fit(x=context.drop_columns(\"spend_30d\"), y=context[\"spend_30d\"], related_tables=related)\n", " batches = []\n", - " for query_batch in evaluation_query.split(batch_size, -2):\n", + " for query_batch in query.split(batch_size, -2):\n", " out = model.predict(*sampler(query_batch, **options).to(device))\n", " columns = list(out.columns[sdm.Stype.numerical])\n", " batches.append(out.numerical[:, [columns.index(c) for c in QUANTILE_COLUMNS]].float().cpu().numpy())\n", " members.append(np.concatenate(batches))\n", - " grid = np.mean(members, axis=0)\n", + " return np.mean(members, axis=0)\n", + "\n", + "\n", + "def score_contexts(contexts, **options):\n", + " grid = predict_grid(contexts, evaluation_query, **options)\n", " return grid[: len(val_rows)], grid[len(val_rows):]\n", "\n", "\n", + "def score_validation(contexts, **options):\n", + " return predict_grid(contexts, evaluation_query[: len(val_rows)], **options)\n", + "\n", + "\n", "def capture(y_true, prediction):\n", - " k = max(1, round(len(y_true) * TOP_SHARE))\n", - " return len(set(np.argsort(-prediction)[:k]) & set(np.argsort(-y_true)[:k])) / k\n", + " in_band = y_true >= top_cut\n", + " k = max(1, int(in_band.sum()))\n", + " return in_band[np.argsort(-prediction)[:k]].sum() / k\n", "\n", "\n", "def metrics(y_true, grid, quantile):\n", @@ -741,10 +747,10 @@ "id": "b423b5c9", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:09.408103Z", - "iopub.status.busy": "2026-11-18T23:54:09.408033Z", - "iopub.status.idle": "2026-11-18T23:54:46.534605Z", - "shell.execute_reply": "2026-11-18T23:54:46.534158Z" + "iopub.execute_input": "2026-11-19T01:20:07.312604Z", + "iopub.status.busy": "2026-11-19T01:20:07.312530Z", + "iopub.status.idle": "2026-11-19T01:21:23.041636Z", + "shell.execute_reply": "2026-11-19T01:21:23.038932Z" } }, "outputs": [ @@ -752,7 +758,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Top-band accounts in the baseline context: 113 of 5000\n" + "Top-band accounts in the baseline context: 103 of 5000\n" ] }, { @@ -786,10 +792,10 @@ " \n", "
\n", " Baseline, median\n", - " 255.456\n", - " 3310.647\n", - " 0.63\n", - " 0.407\n", + " 253.664\n", + " 2828.418\n", + " 0.612\n", + " 0.448\n", " 0.5\n", "
\n", "
\n", @@ -798,7 +804,7 @@ ], "text/plain": [ " mae top_band_mae spearman top_band_capture quantile\n", - "Baseline, median 255.456 3310.647 0.63 0.407 0.5" + "Baseline, median 253.664 2828.418 0.612 0.448 0.5" ] }, "metadata": {}, @@ -828,10 +834,10 @@ "id": "651212df", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:54:46.536270Z", - "iopub.status.busy": "2026-11-18T23:54:46.536183Z", - "iopub.status.idle": "2026-11-18T23:58:20.968395Z", - "shell.execute_reply": "2026-11-18T23:58:20.965537Z" + "iopub.execute_input": "2026-11-19T01:21:23.069934Z", + "iopub.status.busy": "2026-11-19T01:21:23.069602Z", + "iopub.status.idle": "2026-11-19T01:27:45.969560Z", + "shell.execute_reply": "2026-11-19T01:27:45.966066Z" } }, "outputs": [ @@ -865,38 +871,38 @@ " \n", "
\n", " Natural, 5,000 rows\n", - " 0.45\n", - " 266.009\n", - " 268.255\n", - " 3625.974\n", + " 0.40\n", + " 263.107\n", + " 276.051\n", + " 3894.181\n", "
\n", "
\n", " Natural, 10,000 rows\n", - " 0.50\n", - " 255.096\n", - " 255.096\n", - " 3680.133\n", + " 0.45\n", + " 265.194\n", + " 266.302\n", + " 3902.342\n", "
\n", "
\n", " Stratified by band\n", - " 0.40\n", - " 260.854\n", - " 280.912\n", - " 3366.546\n", + " 0.30\n", + " 268.686\n", + " 313.568\n", + " 3777.482\n", "
\n", "
\n", " All top + natural\n", - " 0.40\n", - " 258.651\n", - " 273.511\n", - " 3341.648\n", + " 0.35\n", + " 268.023\n", + " 297.362\n", + " 3824.827\n", "
\n", "
\n", " Top x3 + natural\n", " 0.25\n", - " 283.501\n", - " 366.024\n", - " 3661.430\n", + " 285.010\n", + " 383.530\n", + " 3809.045\n", "
\n", "
\n", "\n", @@ -904,18 +910,18 @@ ], "text/plain": [ " tuned_quantile validation_mae \\\n", - "Natural, 5,000 rows 0.45 266.009 \n", - "Natural, 10,000 rows 0.50 255.096 \n", - "Stratified by band 0.40 260.854 \n", - "All top + natural 0.40 258.651 \n", - "Top x3 + natural 0.25 283.501 \n", + "Natural, 5,000 rows 0.40 263.107 \n", + "Natural, 10,000 rows 0.45 265.194 \n", + "Stratified by band 0.30 268.686 \n", + "All top + natural 0.35 268.023 \n", + "Top x3 + natural 0.25 285.010 \n", "\n", " validation_mae_at_median validation_top_band_mae \n", - "Natural, 5,000 rows 268.255 3625.974 \n", - "Natural, 10,000 rows 255.096 3680.133 \n", - "Stratified by band 280.912 3366.546 \n", - "All top + natural 273.511 3341.648 \n", - "Top x3 + natural 366.024 3661.430 " + "Natural, 5,000 rows 276.051 3894.181 \n", + "Natural, 10,000 rows 266.302 3902.342 \n", + "Stratified by band 313.568 3777.482 \n", + "All top + natural 297.362 3824.827 \n", + "Top x3 + natural 383.530 3809.045 " ] }, "metadata": {}, @@ -925,7 +931,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Selected context design: Natural, 10,000 rows\n" + "Selected context design: Natural, 5,000 rows\n" ] } ], @@ -975,7 +981,7 @@ "id": "aabbb0e1", "metadata": {}, "source": [ - "Oversampling the tail raises the whole predicted distribution, so it needs a lower quantile, and its error at the median grows. Whether it helps after re-tuning depends on how well features already identify the tail.\n", + "Oversampling the tail raises the whole predicted distribution, so it needs a lower quantile, and its error at the median grows. Whether it helps after re-tuning depends on how well features already identify the tail. If the baseline design wins, this stage matches the tuned baseline.\n", "\n", "## Strategy 2: ensemble contexts\n", "\n", @@ -988,10 +994,10 @@ "id": "be6bc210", "metadata": { "execution": { - "iopub.execute_input": "2026-11-18T23:58:20.982008Z", - "iopub.status.busy": "2026-11-18T23:58:20.981452Z", - "iopub.status.idle": "2026-11-19T00:02:36.593778Z", - "shell.execute_reply": "2026-11-19T00:02:36.593216Z" + "iopub.execute_input": "2026-11-19T01:27:45.994607Z", + "iopub.status.busy": "2026-11-19T01:27:45.993914Z", + "iopub.status.idle": "2026-11-19T01:33:31.401527Z", + "shell.execute_reply": "2026-11-19T01:33:31.397947Z" } }, "outputs": [ @@ -999,14 +1005,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Validation MAE per member: [256.9 253.1 274. 257.3 253.7]\n", - "Validation MAE of the ensemble: 242.9\n" + "Validation MAE per member: [268.1 268.4 266.4 263. 259.7]\n", + "Validation MAE of the ensemble: 251.3\n" ] } ], "source": [ "design = context_designs[best_design]\n", - "member_scores = [score_contexts([design(pool_rows)]) for _ in range(NUM_ESTIMATORS)]\n", + "ensemble_contexts = [design(pool_rows) for _ in range(NUM_ESTIMATORS)]\n", + "member_scores = [score_contexts([context]) for context in ensemble_contexts]\n", "stages[\"+ Context ensemble\"] = tuple(np.mean([member[i] for member in member_scores], axis=0) for i in range(2))\n", "print(\"Validation MAE per member:\", np.round([tuned_val_mae(val_grid) for val_grid, _ in member_scores], 1))\n", "print(f\"Validation MAE of the ensemble: {tuned_val_mae(stages['+ Context ensemble'][0]):.1f}\")" @@ -1019,9 +1026,9 @@ "source": [ "## Strategy 3: tune sampling\n", "\n", - "Test each change on a single context and keep it only if validation MAE, at its tuned quantile, improves:\n", + "Test each change on the first ensemble member's context rows, so only the sampling setting changes, and keep it only if validation MAE, at its tuned quantile, improves:\n", "\n", - "* **Recent accounts:** apply the selected design to the pool's last 90 days.\n", + "* **Recent accounts:** apply the selected design to the pool's last 90 days. This can change the context size too.\n", "* **Most recent transactions:** `temporal_strategy=\"last\"` instead of a uniform sample.\n", "* **More neighbors:** more first-hop transactions per account." ] @@ -1032,10 +1039,10 @@ "id": "90e94a4b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:02:36.595863Z", - "iopub.status.busy": "2026-11-19T00:02:36.595750Z", - "iopub.status.idle": "2026-11-19T00:06:57.038682Z", - "shell.execute_reply": "2026-11-19T00:06:57.036395Z" + "iopub.execute_input": "2026-11-19T01:33:31.420847Z", + "iopub.status.busy": "2026-11-19T01:33:31.419794Z", + "iopub.status.idle": "2026-11-19T01:35:39.773348Z", + "shell.execute_reply": "2026-11-19T01:35:39.771539Z" } }, "outputs": [ @@ -1061,7 +1068,7 @@ "
\n", " \n", " change\n", - " recent_accounts\n", + " context_rows\n", " num_neighbors\n", " temporal_strategy\n", " validation_mae\n", @@ -1071,51 +1078,51 @@ "
\n", " 0\n", " Current settings\n", - " False\n", + " 5000\n", " 8\n", " uniform\n", - " 255.434\n", + " 268.115\n", "
\n", "
\n", " 1\n", " Recent accounts\n", - " True\n", + " 5000\n", " 8\n", " uniform\n", - " 257.371\n", + " 270.096\n", "
\n", "
\n", " 2\n", " Most recent transactions\n", - " False\n", + " 5000\n", " 8\n", " last\n", - " 190.550\n", + " 194.881\n", "
\n", "
\n", " 3\n", " 16 neighbors\n", - " False\n", + " 5000\n", " 16\n", " last\n", - " 182.426\n", + " 193.014\n", "
\n", " \n", "\n", "" ], "text/plain": [ - " change recent_accounts num_neighbors temporal_strategy \\\n", - "0 Current settings False 8 uniform \n", - "1 Recent accounts True 8 uniform \n", - "2 Most recent transactions False 8 last \n", - "3 16 neighbors False 16 last \n", + " change context_rows num_neighbors temporal_strategy \\\n", + "0 Current settings 5000 8 uniform \n", + "1 Recent accounts 5000 8 uniform \n", + "2 Most recent transactions 5000 8 last \n", + "3 16 neighbors 5000 16 last \n", "\n", " validation_mae \n", - "0 255.434 \n", - "1 257.371 \n", - "2 190.550 \n", - "3 182.426 " + "0 268.115 \n", + "1 270.096 \n", + "2 194.881 \n", + "3 193.014 " ] }, "metadata": {}, @@ -1133,22 +1140,24 @@ "recent_rows = pool_rows[observation_day[pool_rows] >= VALIDATION_START_DAY - RECENT_CONTEXT_DAYS]\n", "\n", "\n", - "def candidate_context(use_recent):\n", - " return design(recent_rows if use_recent else pool_rows)\n", - "\n", - "\n", + "trial_contexts = {False: ensemble_contexts[0], True: design(recent_rows)}\n", "trials = []\n", "\n", "\n", - "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", - " val_grid, _ = score_contexts([candidate_context(use_recent)], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", - " trials.append({\"change\": change, \"recent_accounts\": use_recent, \"num_neighbors\": num_neighbors,\n", + "def record(change, use_recent, num_neighbors, temporal_strategy, val_grid):\n", + " trials.append({\"change\": change, \"context_rows\": len(trial_contexts[use_recent]), \"num_neighbors\": num_neighbors,\n", " \"temporal_strategy\": temporal_strategy, \"validation_mae\": tuned_val_mae(val_grid)})\n", " return trials[-1][\"validation_mae\"]\n", "\n", "\n", - "settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", - "best_mae = try_settings(\"Current settings\", **settings)\n", + "def try_settings(change, use_recent, num_neighbors, temporal_strategy):\n", + " val_grid = score_validation([trial_contexts[use_recent]], num_neighbors=num_neighbors, temporal_strategy=temporal_strategy)\n", + " return record(change, use_recent, num_neighbors, temporal_strategy, val_grid)\n", + "\n", + "\n", + "default_settings = {\"use_recent\": False, \"num_neighbors\": FIRST_HOP_NEIGHBORS, \"temporal_strategy\": \"uniform\"}\n", + "settings = dict(default_settings)\n", + "best_mae = record(\"Current settings\", **settings, val_grid=member_scores[0][0])\n", "for change, update in [(\"Recent accounts\", {\"use_recent\": True}), (\"Most recent transactions\", {\"temporal_strategy\": \"last\"})] + [\n", " (f\"{n} neighbors\", {\"num_neighbors\": n}) for n in NEIGHBOR_OPTIONS\n", "]:\n", @@ -1165,7 +1174,7 @@ "id": "0aa43f72", "metadata": {}, "source": [ - "Rebuild the ensemble with the selected settings." + "Score the ensemble with the selected settings. It keeps the same members unless the recent pool was selected, which the stage name then states." ] }, { @@ -1174,17 +1183,25 @@ "id": "adf28a60", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:06:57.054163Z", - "iopub.status.busy": "2026-11-19T00:06:57.054069Z", - "iopub.status.idle": "2026-11-19T00:16:04.219889Z", - "shell.execute_reply": "2026-11-19T00:16:04.212067Z" + "iopub.execute_input": "2026-11-19T01:35:39.789457Z", + "iopub.status.busy": "2026-11-19T01:35:39.789340Z", + "iopub.status.idle": "2026-11-19T01:46:49.924051Z", + "shell.execute_reply": "2026-11-19T01:46:49.910727Z" } }, "outputs": [], "source": [ - "final_contexts = [candidate_context(settings[\"use_recent\"]) for _ in range(NUM_ESTIMATORS)]\n", "sampling_options = {\"num_neighbors\": settings[\"num_neighbors\"], \"temporal_strategy\": settings[\"temporal_strategy\"]}\n", - "stages[\"+ Sampling settings\"] = score_contexts(final_contexts, **sampling_options)" + "if settings[\"use_recent\"]:\n", + " final_stage = \"+ Sampling settings (recent pool)\"\n", + " final_contexts = [trial_contexts[True]] + [design(recent_rows) for _ in range(NUM_ESTIMATORS - 1)]\n", + "else:\n", + " final_stage = \"+ Sampling settings\"\n", + " final_contexts = ensemble_contexts\n", + "if settings == default_settings:\n", + " stages[final_stage] = stages[\"+ Context ensemble\"]\n", + "else:\n", + " stages[final_stage] = score_contexts(final_contexts, **sampling_options)" ] }, { @@ -1203,10 +1220,10 @@ "id": "ee0f322b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:16:04.237760Z", - "iopub.status.busy": "2026-11-19T00:16:04.237152Z", - "iopub.status.idle": "2026-11-19T00:16:04.309458Z", - "shell.execute_reply": "2026-11-19T00:16:04.309114Z" + "iopub.execute_input": "2026-11-19T01:46:49.952212Z", + "iopub.status.busy": "2026-11-19T01:46:49.950723Z", + "iopub.status.idle": "2026-11-19T01:46:50.049557Z", + "shell.execute_reply": "2026-11-19T01:46:50.049077Z" } }, "outputs": [ @@ -1237,11 +1254,11 @@ " \n", "
\n", " Baseline\n", - " 0.45\n", + " 0.40\n", "
\n", "
\n", " + Context composition\n", - " 0.50\n", + " 0.40\n", "
\n", "
\n", " + Context ensemble\n", @@ -1257,8 +1274,8 @@ ], "text/plain": [ " mae_quantile\n", - "Baseline 0.45\n", - "+ Context composition 0.50\n", + "Baseline 0.40\n", + "+ Context composition 0.40\n", "+ Context ensemble 0.45\n", "+ Sampling settings 0.50" ] @@ -1286,10 +1303,10 @@ "id": "a0226264", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:16:04.315195Z", - "iopub.status.busy": "2026-11-19T00:16:04.315116Z", - "iopub.status.idle": "2026-11-19T00:16:04.344928Z", - "shell.execute_reply": "2026-11-19T00:16:04.344568Z" + "iopub.execute_input": "2026-11-19T01:46:50.060704Z", + "iopub.status.busy": "2026-11-19T01:46:50.060621Z", + "iopub.status.idle": "2026-11-19T01:46:50.103603Z", + "shell.execute_reply": "2026-11-19T01:46:50.103113Z" } }, "outputs": [ @@ -1326,23 +1343,23 @@ " \n", "
\n", " Min MAE\n", - " 176.841\n", - " 2284.172\n", - " 0.843\n", - " 0.586\n", - " 0.5\n", - " 441.898\n", - " 0.565\n", + " 178.940\n", + " 2116.340\n", + " 0.838\n", + " 0.632\n", + " 0.50\n", + " 427.971\n", + " 0.468\n", "
\n", "
\n", " Under-forecast cost x3\n", - " 220.391\n", - " 2297.835\n", - " 0.830\n", - " 0.590\n", - " 0.7\n", - " 356.572\n", - " 0.249\n", + " 218.072\n", + " 2442.324\n", + " 0.825\n", + " 0.625\n", + " 0.65\n", + " 366.191\n", + " 0.261\n", "
\n", "
\n", "\n", @@ -1350,12 +1367,12 @@ ], "text/plain": [ " mae top_band_mae spearman top_band_capture \\\n", - "Min MAE 176.841 2284.172 0.843 0.586 \n", - "Under-forecast cost x3 220.391 2297.835 0.830 0.590 \n", + "Min MAE 178.940 2116.340 0.838 0.632 \n", + "Under-forecast cost x3 218.072 2442.324 0.825 0.625 \n", "\n", " quantile asymmetric_cost under_forecast_share \n", - "Min MAE 0.5 441.898 0.565 \n", - "Under-forecast cost x3 0.7 356.572 0.249 " + "Min MAE 0.50 427.971 0.468 \n", + "Under-forecast cost x3 0.65 366.191 0.261 " ] }, "metadata": {}, @@ -1363,10 +1380,10 @@ } ], "source": [ - "final_val, final_test = stages[\"+ Sampling settings\"]\n", + "final_val, final_test = stages[final_stage]\n", "cost_quantile = best_quantile(y_val, final_val, under_cost=UNDER_PREDICTION_COST)\n", "operating_points = {}\n", - "for name, quantile in [(\"Min MAE\", tuned_quantiles[\"+ Sampling settings\"]), (f\"Under-forecast cost x{UNDER_PREDICTION_COST:g}\", cost_quantile)]:\n", + "for name, quantile in [(\"Min MAE\", tuned_quantiles[final_stage]), (f\"Under-forecast cost x{UNDER_PREDICTION_COST:g}\", cost_quantile)]:\n", " prediction = final_test[:, QUANTILES.index(quantile)]\n", " errors = prediction - y_test\n", " operating_points[name] = {\n", @@ -1393,10 +1410,10 @@ "id": "f6dc0fe0", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:16:04.346097Z", - "iopub.status.busy": "2026-11-19T00:16:04.346042Z", - "iopub.status.idle": "2026-11-19T00:16:04.427820Z", - "shell.execute_reply": "2026-11-19T00:16:04.427491Z" + "iopub.execute_input": "2026-11-19T01:46:50.105901Z", + "iopub.status.busy": "2026-11-19T01:46:50.105745Z", + "iopub.status.idle": "2026-11-19T01:46:50.193359Z", + "shell.execute_reply": "2026-11-19T01:46:50.192641Z" } }, "outputs": [ @@ -1431,42 +1448,42 @@ " \n", "
\n", " Baseline, median\n", - " 255.456\n", - " 3310.647\n", - " 0.630\n", - " 0.407\n", + " 253.664\n", + " 2828.418\n", + " 0.612\n", + " 0.448\n", " 0.50\n", "
\n", "
\n", " Baseline, tuned quantile\n", - " 254.218\n", - " 3250.494\n", - " 0.625\n", - " 0.410\n", - " 0.45\n", + " 246.187\n", + " 3017.136\n", + " 0.627\n", + " 0.444\n", + " 0.40\n", "
\n", "
\n", " + Context composition\n", - " 244.480\n", - " 3111.331\n", - " 0.642\n", - " 0.410\n", - " 0.50\n", + " 246.187\n", + " 3017.136\n", + " 0.627\n", + " 0.444\n", + " 0.40\n", "
\n", "
\n", " + Context ensemble\n", - " 237.214\n", - " 3058.142\n", - " 0.744\n", - " 0.428\n", + " 236.840\n", + " 2949.089\n", + " 0.748\n", + " 0.476\n", " 0.45\n", "
\n", "
\n", " + Sampling settings\n", - " 176.841\n", - " 2284.172\n", - " 0.843\n", - " 0.586\n", + " 178.940\n", + " 2116.340\n", + " 0.838\n", + " 0.632\n", " 0.50\n", "
\n", "
\n", @@ -1475,16 +1492,16 @@ ], "text/plain": [ " mae top_band_mae spearman top_band_capture \\\n", - "Baseline, median 255.456 3310.647 0.630 0.407 \n", - "Baseline, tuned quantile 254.218 3250.494 0.625 0.410 \n", - "+ Context composition 244.480 3111.331 0.642 0.410 \n", - "+ Context ensemble 237.214 3058.142 0.744 0.428 \n", - "+ Sampling settings 176.841 2284.172 0.843 0.586 \n", + "Baseline, median 253.664 2828.418 0.612 0.448 \n", + "Baseline, tuned quantile 246.187 3017.136 0.627 0.444 \n", + "+ Context composition 246.187 3017.136 0.627 0.444 \n", + "+ Context ensemble 236.840 2949.089 0.748 0.476 \n", + "+ Sampling settings 178.940 2116.340 0.838 0.632 \n", "\n", " quantile \n", "Baseline, median 0.50 \n", - "Baseline, tuned quantile 0.45 \n", - "+ Context composition 0.50 \n", + "Baseline, tuned quantile 0.40 \n", + "+ Context composition 0.40 \n", "+ Context ensemble 0.45 \n", "+ Sampling settings 0.50 " ] @@ -1496,7 +1513,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "MAE: 255.5 -> 176.8; top-band MAE: 3310.6 -> 2284.2; Spearman: 0.630 -> 0.843\n" + "MAE: 253.7 -> 178.9; top-band MAE: 2828.4 -> 2116.3; Spearman: 0.612 -> 0.838\n" ] } ], @@ -1526,16 +1543,16 @@ "id": "3158e49b", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:16:04.429193Z", - "iopub.status.busy": "2026-11-19T00:16:04.429129Z", - "iopub.status.idle": "2026-11-19T00:16:04.787291Z", - "shell.execute_reply": "2026-11-19T00:16:04.786946Z" + "iopub.execute_input": "2026-11-19T01:46:50.196218Z", + "iopub.status.busy": "2026-11-19T01:46:50.196065Z", + "iopub.status.idle": "2026-11-19T01:46:51.042994Z", + "shell.execute_reply": "2026-11-19T01:46:51.042223Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1578,10 +1595,10 @@ "id": "cec08f14", "metadata": { "execution": { - "iopub.execute_input": "2026-11-19T00:16:04.788793Z", - "iopub.status.busy": "2026-11-19T00:16:04.788712Z", - "iopub.status.idle": "2026-11-19T00:16:04.791551Z", - "shell.execute_reply": "2026-11-19T00:16:04.791154Z" + "iopub.execute_input": "2026-11-19T01:46:51.045662Z", + "iopub.status.busy": "2026-11-19T01:46:51.045456Z", + "iopub.status.idle": "2026-11-19T01:46:51.049255Z", + "shell.execute_reply": "2026-11-19T01:46:51.048433Z" } }, "outputs": [ @@ -1589,7 +1606,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-73ej8kxe.\n" + "Results retained in /var/folders/d1/l_l86lcn0jb9jls_r4k74tbc0000gn/T/spend-context-tuning-_zl0q29z.\n" ] } ],