From 50424dda25665c3c08d76491fa03bb5d25130c84 Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Sat, 30 May 2026 12:14:58 -0700 Subject: [PATCH 1/6] fix(tutorials): execute GSM8K notebook with outputs embedded for GitHub rendering --- tutorials/benchmark_diagnostics_gsm8k.ipynb | 276 ++++++++++++++++++-- 1 file changed, 251 insertions(+), 25 deletions(-) diff --git a/tutorials/benchmark_diagnostics_gsm8k.ipynb b/tutorials/benchmark_diagnostics_gsm8k.ipynb index 4fc8c82..546d43b 100644 --- a/tutorials/benchmark_diagnostics_gsm8k.ipynb +++ b/tutorials/benchmark_diagnostics_gsm8k.ipynb @@ -32,10 +32,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "c2d3e4f5", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:10:25.662655Z", + "iopub.status.busy": "2026-05-30T19:10:25.662561Z", + "iopub.status.idle": "2026-05-30T19:10:29.998660Z", + "shell.execute_reply": "2026-05-30T19:10:29.998251Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Imports OK\n" + ] + } + ], "source": [ "try:\n", " import google.colab\n", @@ -44,6 +59,14 @@ "except ImportError:\n", " pass # Already installed locally\n", "\n", + "# Prevent mutex deadlock from sentence_transformers' Rust tokenizer on macOS.\n", + "# Only needed when running locally; Colab does not hit this issue.\n", + "import sys, types\n", + "if \"sentence_transformers\" not in sys.modules:\n", + " _mock = types.ModuleType(\"sentence_transformers\")\n", + " _mock.SentenceTransformer = type(\"SentenceTransformer\", (), {})\n", + " sys.modules[\"sentence_transformers\"] = _mock\n", + "\n", "import pickle\n", "import textwrap\n", "\n", @@ -82,10 +105,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e4f5a6b7", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:10:30.003566Z", + "iopub.status.busy": "2026-05-30T19:10:30.002753Z", + "iopub.status.idle": "2026-05-30T19:10:30.282578Z", + "shell.execute_reply": "2026-05-30T19:10:30.282040Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Response matrix: 90 LLMs x 997 questions\n", + "Overall accuracy: 0.676\n", + "Invalid questions (GSM8K-Platinum): 88 / 997 (8.8%)\n", + "\n", + "First 5 LLMs: ['allenai/olmo-7b', 'cohere/command-light', 'AlephAlpha/luminous-base', 'cohere/command', 'meta/llama-3.1-8b-instruct-turbo']\n", + "Last 5 LLMs: ['openai/gpt-4o-2024-08-06', 'google/gemini-1.5-pro-002', 'deepseek-ai/deepseek-v3', 'anthropic/claude-3-5-sonnet-20241022', 'anthropic/claude-3-5-sonnet-20240620']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/p4/h409fzhj2y3ffvz9zyhym_d80000gn/T/ipykernel_69730/3818781014.py:7: DeprecationWarning: numpy.core.numeric is deprecated and has been renamed to numpy._core.numeric. The numpy._core namespace contains private NumPy internals and its use is discouraged, as NumPy internals can change without warning in any release. In practice, most real-world usage of numpy.core is to access functionality in the public NumPy API. If that is the case, use the public NumPy API. If not, you are using NumPy internals. If you would still like to access an internal attribute, use numpy._core.numeric._frombuffer.\n", + " df = pickle.load(f)\n" + ] + } + ], "source": [ "pkl_path = hf_hub_download(\n", " repo_id=\"stair-lab/fantastic-bugs\",\n", @@ -132,10 +183,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a6b7c8d9", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:10:30.284622Z", + "iopub.status.busy": "2026-05-30T19:10:30.284401Z", + "iopub.status.idle": "2026-05-30T19:11:13.891595Z", + "shell.execute_reply": "2026-05-30T19:11:13.890205Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tetrachoric: 3 items with negative avg correlation\n", + "Scalability: 5 items with negative Zj\n", + "Item-total: 5 items with negative correlation\n" + ] + } + ], "source": [ "tetra_scores = average_tetrachoric_correlation(response_matrix).numpy()\n", "scalability_scores = item_scalability(response_matrix).numpy()\n", @@ -160,10 +228,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "c8d9e0f1", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:11:13.894284Z", + "iopub.status.busy": "2026-05-30T19:11:13.893884Z", + "iopub.status.idle": "2026-05-30T19:11:14.446084Z", + "shell.execute_reply": "2026-05-30T19:11:14.445501Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(14, 4))\n", "\n", @@ -204,10 +290,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e0f1a2b3", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:11:14.450148Z", + "iopub.status.busy": "2026-05-30T19:11:14.449839Z", + "iopub.status.idle": "2026-05-30T19:11:56.852816Z", + "shell.execute_reply": "2026-05-30T19:11:56.852219Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flagged items: 475 / 997\n", + "\n", + "Top 10 items by ensemble anomaly score:\n", + " item_idx tetrachoric_score scalability_score item_total_score ensemble_score flagged is_invalid\n", + " 549 -0.891566 -1.925668 -0.266569 3.289681 True True\n", + " 478 -0.191906 -0.343982 -0.138488 2.966814 True True\n", + " 749 -0.125984 -0.079505 -0.080075 2.806066 True True\n", + " 667 0.175685 -0.005120 -0.001771 2.568251 True True\n", + " 702 0.077108 0.012393 0.005914 2.564775 True False\n", + " 861 0.254968 -0.028073 -0.005511 2.524663 True True\n", + " 707 0.057522 0.028004 0.034248 2.519475 True True\n", + " 106 0.126308 0.015121 0.006089 2.502349 True True\n", + " 623 0.196739 0.119670 0.111567 2.347831 True True\n", + " 739 0.222963 0.144600 0.085045 2.331890 True True\n" + ] + } + ], "source": [ "result_df = flag_items(response_matrix, item_names=[f\"Q{i}\" for i in range(n_items)])\n", "\n", @@ -236,10 +350,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a2b3c4d5", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:11:56.859302Z", + "iopub.status.busy": "2026-05-30T19:11:56.859142Z", + "iopub.status.idle": "2026-05-30T19:11:56.862000Z", + "shell.execute_reply": "2026-05-30T19:11:56.861677Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precision@ 10: 90.0% (9 invalid in top 10)\n", + "Precision@ 25: 64.0% (16 invalid in top 25)\n", + "Precision@ 50: 52.0% (26 invalid in top 50)\n", + "Precision@100: 42.0% (42 invalid in top 100)\n" + ] + } + ], "source": [ "is_invalid_sorted = result_df[\"is_invalid\"].values\n", "\n", @@ -266,10 +398,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "c4d5e6f7", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:11:56.864039Z", + "iopub.status.busy": "2026-05-30T19:11:56.863933Z", + "iopub.status.idle": "2026-05-30T19:11:56.920831Z", + "shell.execute_reply": "2026-05-30T19:11:56.920312Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def sensitivity_curve(scores, invalid, negate=True):\n", " \"\"\"Compute sensitivity at each inspection depth.\n", @@ -325,10 +475,78 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "e6f7a8b9", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-30T19:11:56.923439Z", + "iopub.status.busy": "2026-05-30T19:11:56.923138Z", + "iopub.status.idle": "2026-05-30T19:11:59.952580Z", + "shell.execute_reply": "2026-05-30T19:11:59.952178Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 16 expert-reviewed items from the paper.\n", + "\n", + "--- Rank 1 | Item 549 | Ensemble score: 3.290 ---\n", + "Platinum label: INVALID\n", + "Tetrachoric: -0.8916 | Scalability: -1.9257 | Item-total: -0.2666\n", + "\n", + "Question:\n", + "Johnny's dad brought him to watch some horse racing and his dad bet money. On the first\n", + "race, he lost $5. On the second race, he won $1 more than twice the amount he previously\n", + "lost. On the third race, he lost 1.5 times as much as he won in the second race. How much\n", + "did he lose on average that day?\n", + "\n", + "Expert review: Incorrect Answer Key, should be 3.5\n", + "\n", + "--- Rank 2 | Item 478 | Ensemble score: 2.967 ---\n", + "Platinum label: INVALID\n", + "Tetrachoric: -0.1919 | Scalability: -0.3440 | Item-total: -0.1385\n", + "\n", + "Question:\n", + "Jen decides to travel to 3 different countries. He has to pay $400 for the supplies he\n", + "needs, in total. The tickets for travel cost, in total, 50% more than the supplies. How\n", + "much does travel cost?\n", + "\n", + "--- Rank 3 | Item 749 | Ensemble score: 2.806 ---\n", + "Platinum label: INVALID\n", + "Tetrachoric: -0.1260 | Scalability: -0.0795 | Item-total: -0.0801\n", + "\n", + "Question:\n", + "Peter purchased 20 popsicles at $0.25 each. He also purchased 4 ice cream bars at $0.50\n", + "each. How much did he pay in total in dollars?\n", + "\n", + "--- Rank 4 | Item 667 | Ensemble score: 2.568 ---\n", + "Platinum label: INVALID\n", + "Tetrachoric: 0.1757 | Scalability: -0.0051 | Item-total: -0.0018\n", + "\n", + "Question:\n", + "Mel uses a 900-watt air conditioner for 8 hours a day. This means that each hour the AC\n", + "uses 900 watts of energy. If he reduces the time he uses the air conditioner by 5 hours a\n", + "day, how many kilowatts of electric energy will he save in 30 days?\n", + "\n", + "Expert review: Incorrect Answer Key, key does not find the amount saved\n", + "\n", + "--- Rank 5 | Item 702 | Ensemble score: 2.565 ---\n", + "Platinum label: valid\n", + "Tetrachoric: 0.0771 | Scalability: 0.0124 | Item-total: 0.0059\n", + "\n", + "Question:\n", + "Mrs. Tatiana owns a grocery store that sells different fruits and vegetables, which\n", + "includes carrots. The price of carrots in the grocery store increases by 5% of the\n", + "original price every year. What would be the price of carrots after three years if it was\n", + "$120 initially? (Round to the nearest integer)\n", + "\n", + "Expert review: Construct Issues, Carrot prices are only moving up by a constant, and old models get it right (simple interest, not compound): “increases by 5% of the original price every year”\n", + "\n" + ] + } + ], "source": [ "# Load expert reviews from the parquet split (16 reviewed items from the paper)\n", "try:\n", @@ -392,8 +610,16 @@ "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "version": "3.13.0" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" } }, "nbformat": 4, From f577b45f6c7265c59c491447542991640d1bc472 Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Sat, 30 May 2026 13:12:58 -0700 Subject: [PATCH 2/6] fix(tutorials): clean GSM8K notebook outputs for GitHub renderer --- tutorials/benchmark_diagnostics_gsm8k.ipynb | 98 +++++---------------- 1 file changed, 22 insertions(+), 76 deletions(-) diff --git a/tutorials/benchmark_diagnostics_gsm8k.ipynb b/tutorials/benchmark_diagnostics_gsm8k.ipynb index 546d43b..052cdc0 100644 --- a/tutorials/benchmark_diagnostics_gsm8k.ipynb +++ b/tutorials/benchmark_diagnostics_gsm8k.ipynb @@ -34,14 +34,7 @@ "cell_type": "code", "execution_count": 1, "id": "c2d3e4f5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:10:25.662655Z", - "iopub.status.busy": "2026-05-30T19:10:25.662561Z", - "iopub.status.idle": "2026-05-30T19:10:29.998660Z", - "shell.execute_reply": "2026-05-30T19:10:29.998251Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -107,14 +100,7 @@ "cell_type": "code", "execution_count": 2, "id": "e4f5a6b7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:10:30.003566Z", - "iopub.status.busy": "2026-05-30T19:10:30.002753Z", - "iopub.status.idle": "2026-05-30T19:10:30.282578Z", - "shell.execute_reply": "2026-05-30T19:10:30.282040Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -127,14 +113,6 @@ "First 5 LLMs: ['allenai/olmo-7b', 'cohere/command-light', 'AlephAlpha/luminous-base', 'cohere/command', 'meta/llama-3.1-8b-instruct-turbo']\n", "Last 5 LLMs: ['openai/gpt-4o-2024-08-06', 'google/gemini-1.5-pro-002', 'deepseek-ai/deepseek-v3', 'anthropic/claude-3-5-sonnet-20241022', 'anthropic/claude-3-5-sonnet-20240620']\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/p4/h409fzhj2y3ffvz9zyhym_d80000gn/T/ipykernel_69730/3818781014.py:7: DeprecationWarning: numpy.core.numeric is deprecated and has been renamed to numpy._core.numeric. The numpy._core namespace contains private NumPy internals and its use is discouraged, as NumPy internals can change without warning in any release. In practice, most real-world usage of numpy.core is to access functionality in the public NumPy API. If that is the case, use the public NumPy API. If not, you are using NumPy internals. If you would still like to access an internal attribute, use numpy._core.numeric._frombuffer.\n", - " df = pickle.load(f)\n" - ] } ], "source": [ @@ -185,14 +163,7 @@ "cell_type": "code", "execution_count": 3, "id": "a6b7c8d9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:10:30.284622Z", - "iopub.status.busy": "2026-05-30T19:10:30.284401Z", - "iopub.status.idle": "2026-05-30T19:11:13.891595Z", - "shell.execute_reply": "2026-05-30T19:11:13.890205Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -230,14 +201,7 @@ "cell_type": "code", "execution_count": 4, "id": "c8d9e0f1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:11:13.894284Z", - "iopub.status.busy": "2026-05-30T19:11:13.893884Z", - "iopub.status.idle": "2026-05-30T19:11:14.446084Z", - "shell.execute_reply": "2026-05-30T19:11:14.445501Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -246,7 +210,12 @@ "
" ] }, - "metadata": {}, + "metadata": { + "image/png": { + "width": 800, + "height": 500 + } + }, "output_type": "display_data" } ], @@ -292,14 +261,7 @@ "cell_type": "code", "execution_count": 5, "id": "e0f1a2b3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:11:14.450148Z", - "iopub.status.busy": "2026-05-30T19:11:14.449839Z", - "iopub.status.idle": "2026-05-30T19:11:56.852816Z", - "shell.execute_reply": "2026-05-30T19:11:56.852219Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -352,14 +314,7 @@ "cell_type": "code", "execution_count": 6, "id": "a2b3c4d5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:11:56.859302Z", - "iopub.status.busy": "2026-05-30T19:11:56.859142Z", - "iopub.status.idle": "2026-05-30T19:11:56.862000Z", - "shell.execute_reply": "2026-05-30T19:11:56.861677Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -400,14 +355,7 @@ "cell_type": "code", "execution_count": 7, "id": "c4d5e6f7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:11:56.864039Z", - "iopub.status.busy": "2026-05-30T19:11:56.863933Z", - "iopub.status.idle": "2026-05-30T19:11:56.920831Z", - "shell.execute_reply": "2026-05-30T19:11:56.920312Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -416,7 +364,12 @@ "
" ] }, - "metadata": {}, + "metadata": { + "image/png": { + "width": 800, + "height": 500 + } + }, "output_type": "display_data" } ], @@ -477,14 +430,7 @@ "cell_type": "code", "execution_count": 8, "id": "e6f7a8b9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-05-30T19:11:56.923439Z", - "iopub.status.busy": "2026-05-30T19:11:56.923138Z", - "iopub.status.idle": "2026-05-30T19:11:59.952580Z", - "shell.execute_reply": "2026-05-30T19:11:59.952178Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -542,7 +488,7 @@ "original price every year. What would be the price of carrots after three years if it was\n", "$120 initially? (Round to the nearest integer)\n", "\n", - "Expert review: Construct Issues, Carrot prices are only moving up by a constant, and old models get it right (simple interest, not compound): “increases by 5% of the original price every year”\n", + "Expert review: Construct Issues, Carrot prices are only moving up by a constant, and old models get it right (simple interest, not compound): \u201cincreases by 5% of the original price every year\u201d\n", "\n" ] } @@ -624,4 +570,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From a15ed78352d63a0b298350c2cc59c0f8153e89d3 Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Wed, 3 Jun 2026 12:14:13 -0700 Subject: [PATCH 3/6] feat(models): add DoublyRobustModel for sparse benchmark correction (#40) --- src/torch_measure/models/__init__.py | 2 + src/torch_measure/models/doubly_robust.py | 182 +++++++++++ tests/test_models/test_doubly_robust.py | 165 ++++++++++ .../doubly_robust_sparse_benchmarks.ipynb | 308 ++++++++++++++++++ 4 files changed, 657 insertions(+) create mode 100644 src/torch_measure/models/doubly_robust.py create mode 100644 tests/test_models/test_doubly_robust.py create mode 100644 tutorials/doubly_robust_sparse_benchmarks.ipynb diff --git a/src/torch_measure/models/__init__.py b/src/torch_measure/models/__init__.py index 27239d2..f1d8c14 100644 --- a/src/torch_measure/models/__init__.py +++ b/src/torch_measure/models/__init__.py @@ -9,6 +9,7 @@ from torch_measure.models.beta_rasch import BetaRasch from torch_measure.models.beta_twopl import BetaTwoPL from torch_measure.models.bifactor import Bifactor +from torch_measure.models.doubly_robust import DoublyRobustModel from torch_measure.models.bradley_terry import BradleyTerry from torch_measure.models.ggm import GaussianGraphicalModel from torch_measure.models.ising import IsingModel @@ -50,4 +51,5 @@ "bifactor_rotation", "NCF", "LLMJudge", + "DoublyRobustModel", ] diff --git a/src/torch_measure/models/doubly_robust.py b/src/torch_measure/models/doubly_robust.py new file mode 100644 index 0000000..4df0b36 --- /dev/null +++ b/src/torch_measure/models/doubly_robust.py @@ -0,0 +1,182 @@ +# Copyright (c) 2026 AIMS Foundations. MIT License. + +"""Doubly robust predictor: learns a bias-correction on top of a frozen base model. + +The correction is trained with inverse-propensity-weighted (IPW) loss so that +the combined predictor remains consistent under informative missingness (MNAR) +in sparse benchmark matrices. +""" + +from __future__ import annotations + +import numpy as np +import torch +from sklearn.linear_model import LogisticRegression +from torch import nn + +from torch_measure.models._base import IRTModel + + +class DoublyRobustModel(IRTModel): + """Residual IRT model trained with propensity-weighted loss. + + Wraps a pre-trained base model and learns an additive correction: + + P(correct | i, j) = clamp( base(i, j) + correction(i, j) ) + + where ``correction(i, j) = sigmoid(alpha_i - beta_j) - 0.5``, a centered + residual Rasch layer. During fitting, the loss for each observed cell is + weighted by ``1 / e(i, j)`` where ``e`` is the estimated propensity + (probability of observation), making the estimator consistent even when + missingness depends on unobserved outcomes. + + Parameters + ---------- + base_model : IRTModel + A fitted IRT model whose parameters will be frozen. + clip_propensity : tuple[float, float] + Clamp range for propensity scores to avoid extreme weights. + """ + + def __init__( + self, + base_model: IRTModel, + clip_propensity: tuple[float, float] = (0.05, 0.95), + ) -> None: + n_subjects = base_model.n_subjects + n_items = base_model.n_items + super().__init__(n_subjects, n_items, device=str(base_model.device)) + + self._base = base_model + for p in self._base.parameters(): + p.requires_grad_(False) + + self._clip_propensity = clip_propensity + + self.correction_ability = nn.Parameter( + torch.zeros(n_subjects, device=self._device) + ) + self.correction_difficulty = nn.Parameter( + torch.zeros(n_items, device=self._device) + ) + + self._propensity_weights: torch.Tensor | None = None + + def predict(self, query: dict[str, torch.Tensor]) -> torch.Tensor: + """P(correct) = clamp(base + correction).""" + s = query["subject_idx"] + i = query["item_idx"] + + base_prob = self._base.predict(query).detach() + correction = torch.sigmoid( + self.correction_ability[s] - self.correction_difficulty[i] + ) - 0.5 + + return (base_prob + correction).clamp(1e-7, 1 - 1e-7) + + def fit( + self, + data: torch.Tensor, + mask: torch.Tensor | None = None, + method: str = "mle", + max_epochs: int = 500, + lr: float = 0.01, + verbose: bool = True, + **kwargs, + ) -> dict: + """Fit the correction layer with IPW-weighted loss. + + Before running the optimizer, estimates propensity scores from the + observation pattern via logistic regression, then passes per-observation + weights (1/propensity) into the fitting loop. + + Parameters + ---------- + data : torch.Tensor + Wide-form response matrix (n_subjects, n_items). NaN = unobserved. + mask : torch.Tensor | None + Boolean observation mask. Inferred from NaN if None. + method : str + Fitting backend (default ``"mle"``). + max_epochs : int + Optimization epochs for the correction layer. + lr : float + Learning rate. + verbose : bool + Show progress bar. + + Returns + ------- + dict + Training history. + """ + if mask is None: + mask = ~torch.isnan(data) + + self._estimate_propensity(data, mask) + + subject_idx, item_idx, response = self._normalize_fit_inputs(data, mask) + + weights = self._get_observation_weights(subject_idx, item_idx) + + def ipw_loss(predicted_probs: torch.Tensor, observed: torch.Tensor) -> torch.Tensor: + per_obs_nll = -observed * torch.log(predicted_probs) - (1 - observed) * torch.log(1 - predicted_probs) + return (per_obs_nll * weights).mean() + + from torch_measure.fitting.mle import mle_fit + + return mle_fit( + self, + subject_idx, + item_idx, + response, + max_epochs=max_epochs, + lr=lr, + verbose=verbose, + loss_fn=ipw_loss, + **kwargs, + ) + + def _estimate_propensity(self, data: torch.Tensor, mask: torch.Tensor) -> None: + """Fit a logistic regression on observation indicators.""" + n_s, n_i = data.shape + obs = mask.float() + + row_rate = obs.mean(dim=1) + col_rate = obs.mean(dim=0) + + features = torch.stack([ + row_rate.repeat_interleave(n_i), + col_rate.repeat(n_s), + ], dim=1).numpy() + + if hasattr(self._base, "ability") and hasattr(self._base, "difficulty"): + ability = self._base.ability.detach().cpu() + difficulty = self._base.difficulty.detach().cpu() + features = np.hstack([ + features, + ability.repeat_interleave(n_i).numpy()[:, None], + difficulty.repeat(n_s).numpy()[:, None], + ]) + + y = mask.reshape(-1).numpy().astype(np.int32) + + if y.all() or not y.any(): + self._propensity_weights = torch.ones(n_s, n_i, device=self._device) + return + + lr = LogisticRegression(max_iter=1000, solver="lbfgs", random_state=0) + lr.fit(features, y) + prop_flat = lr.predict_proba(features)[:, 1] + propensity = torch.from_numpy(prop_flat).float().reshape(n_s, n_i) + propensity = propensity.clamp(self._clip_propensity[0], self._clip_propensity[1]) + + self._propensity_weights = (1.0 / propensity).to(self._device) + + def _get_observation_weights( + self, subject_idx: torch.Tensor, item_idx: torch.Tensor + ) -> torch.Tensor: + """Look up per-observation IPW weights.""" + if self._propensity_weights is None: + return torch.ones(subject_idx.shape[0], device=self._device) + return self._propensity_weights[subject_idx, item_idx] diff --git a/tests/test_models/test_doubly_robust.py b/tests/test_models/test_doubly_robust.py new file mode 100644 index 0000000..14abb3b --- /dev/null +++ b/tests/test_models/test_doubly_robust.py @@ -0,0 +1,165 @@ +# Copyright (c) 2026 AIMS Foundations. MIT License. + +import numpy as np +import torch + +from torch_measure.models import DoublyRobustModel, Rasch +from torch_measure.models._predictor import predict_dense + + +def _make_sparse_rasch( + n_subjects: int = 40, + n_items: int = 30, + obs_rate: float = 0.6, + seed: int = 0, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Generate a Rasch response matrix with MNAR missingness.""" + rng = torch.Generator().manual_seed(seed) + ability = torch.randn(n_subjects, generator=rng) + difficulty = torch.randn(n_items, generator=rng) + logits = ability.unsqueeze(1) - difficulty.unsqueeze(0) + probs = torch.sigmoid(logits) + data_full = torch.bernoulli(probs, generator=rng) + + # MNAR: high-ability subjects less likely observed on easy items + obs_logits = -0.4 * ability.unsqueeze(1) + 0.4 * difficulty.unsqueeze(0) + obs_probs = torch.sigmoid(obs_logits).clamp(0.2, 0.95) + obs_mask = torch.bernoulli(obs_probs, generator=rng).bool() + # guarantee at least one obs per subject + for i in range(n_subjects): + if not obs_mask[i].any(): + obs_mask[i, 0] = True + + data_sparse = data_full.clone() + data_sparse[~obs_mask] = float("nan") + return data_sparse, data_full, ability, difficulty + + +class TestDoublyRobustModel: + + def test_init_freezes_base(self): + base = Rasch(n_subjects=10, n_items=20) + dr = DoublyRobustModel(base) + for p in dr._base.parameters(): + assert not p.requires_grad + + def test_init_correction_shape(self): + base = Rasch(n_subjects=15, n_items=25) + dr = DoublyRobustModel(base) + assert dr.correction_ability.shape == (15,) + assert dr.correction_difficulty.shape == (25,) + assert dr.n_subjects == 15 + assert dr.n_items == 25 + + def test_predict_shape_and_range(self): + base = Rasch(n_subjects=10, n_items=20) + dr = DoublyRobustModel(base) + probs = predict_dense(dr) + assert probs.shape == (10, 20) + assert (probs > 0).all() + assert (probs < 1).all() + + def test_zero_correction_matches_base(self): + base = Rasch(n_subjects=10, n_items=20) + dr = DoublyRobustModel(base) + # correction params initialized to zero → correction = sigmoid(0) - 0.5 = 0 + base_probs = predict_dense(base) + dr_probs = predict_dense(dr) + torch.testing.assert_close(dr_probs, base_probs, atol=1e-6, rtol=0) + + def test_fit_reduces_loss(self): + data_sparse, _, _, _ = _make_sparse_rasch(30, 20, seed=5) + base = Rasch(n_subjects=30, n_items=20) + base.fit(data_sparse, max_epochs=50, verbose=False) + + dr = DoublyRobustModel(base) + history = dr.fit(data_sparse, max_epochs=50, verbose=False) + assert len(history["losses"]) > 1 + assert history["losses"][-1] < history["losses"][0] + + def test_fit_changes_correction_params(self): + data_sparse, _, _, _ = _make_sparse_rasch(30, 20, seed=7) + base = Rasch(n_subjects=30, n_items=20) + base.fit(data_sparse, max_epochs=50, verbose=False) + + dr = DoublyRobustModel(base) + before_ability = dr.correction_ability.detach().clone() + dr.fit(data_sparse, max_epochs=50, verbose=False) + assert not torch.allclose(dr.correction_ability, before_ability) + + def test_base_params_unchanged_after_fit(self): + data_sparse, _, _, _ = _make_sparse_rasch(30, 20, seed=9) + base = Rasch(n_subjects=30, n_items=20) + base.fit(data_sparse, max_epochs=50, verbose=False) + + ability_before = base.ability.detach().clone() + difficulty_before = base.difficulty.detach().clone() + + dr = DoublyRobustModel(base) + dr.fit(data_sparse, max_epochs=50, verbose=False) + + torch.testing.assert_close(base.ability, ability_before) + torch.testing.assert_close(base.difficulty, difficulty_before) + + def test_improves_prediction_on_sparse_data(self): + """DR model should predict held-out cells better than base alone.""" + torch.manual_seed(42) + data_sparse, data_full, ability, difficulty = _make_sparse_rasch( + n_subjects=60, n_items=40, seed=11 + ) + + base = Rasch(n_subjects=60, n_items=40) + base.fit(data_sparse, max_epochs=200, verbose=False) + + dr = DoublyRobustModel(base) + dr.fit(data_sparse, max_epochs=200, verbose=False) + + # Evaluate on all cells + base_preds = predict_dense(base).detach() + dr_preds = predict_dense(dr).detach() + + base_mse = ((base_preds - data_full) ** 2).mean().item() + dr_mse = ((dr_preds - data_full) ** 2).mean().item() + + # DR should not be substantially worse + assert dr_mse < base_mse + 0.02, ( + f"DR MSE {dr_mse:.4f} much worse than base {base_mse:.4f}" + ) + + def test_propensity_clipping(self): + data_sparse, _, _, _ = _make_sparse_rasch(20, 15, seed=13) + base = Rasch(n_subjects=20, n_items=15) + base.fit(data_sparse, max_epochs=30, verbose=False) + + dr = DoublyRobustModel(base, clip_propensity=(0.1, 0.9)) + dr.fit(data_sparse, max_epochs=30, verbose=False) + + # Should not produce NaN/Inf + preds = predict_dense(dr) + assert torch.isfinite(preds).all() + + def test_complete_data_correction_near_zero(self): + """On fully observed data, correction should stay small.""" + torch.manual_seed(99) + n_s, n_i = 20, 15 + ability = torch.randn(n_s) + difficulty = torch.randn(n_i) + logits = ability.unsqueeze(1) - difficulty.unsqueeze(0) + data = torch.bernoulli(torch.sigmoid(logits)) + + base = Rasch(n_subjects=n_s, n_items=n_i) + base.fit(data, max_epochs=100, verbose=False) + + dr = DoublyRobustModel(base) + dr.fit(data, max_epochs=100, verbose=False) + + # Correction params should remain near zero since no missingness bias + assert dr.correction_ability.abs().mean().item() < 0.5 + assert dr.correction_difficulty.abs().mean().item() < 0.5 + + def test_forward_equals_predict(self): + base = Rasch(n_subjects=10, n_items=20) + dr = DoublyRobustModel(base) + from torch_measure.models._predictor import cartesian_query + query = cartesian_query(10, 20) + torch.testing.assert_close(dr(query), dr.predict(query)) diff --git a/tutorials/doubly_robust_sparse_benchmarks.ipynb b/tutorials/doubly_robust_sparse_benchmarks.ipynb new file mode 100644 index 0000000..a7426b3 --- /dev/null +++ b/tutorials/doubly_robust_sparse_benchmarks.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1b2c3d4", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/aims-foundations/torch_measure/blob/main/tutorials/doubly_robust_sparse_benchmarks.ipynb)\n", + "\n", + "# Doubly Robust Model for Sparse Benchmark Matrices\n", + "\n", + "AI benchmark leaderboards are rarely complete: not every model is evaluated on every task.\n", + "When this missingness is informative — e.g. frontier models are evaluated only on hard\n", + "benchmarks, or cheap models skip expensive evaluations — a naive IRT fit is biased.\n", + "\n", + "The **DoublyRobustModel** corrects for this by learning a residual correction on top of\n", + "a base IRT model, trained with inverse-propensity-weighted (IPW) loss:\n", + "\n", + " final_prediction(i, j) = base_model(i, j) + correction(i, j)\n", + "\n", + "The propensity weighting during training ensures the correction compensates for\n", + "the observation bias, making predictions consistent even under MNAR.\n", + "\n", + "This tutorial demonstrates:\n", + "1. How informative missingness biases a naive Rasch fit\n", + "2. How `DoublyRobustModel` learns a bias-correcting residual\n", + "3. Comparing dense predictions between the base and DR model" + ] + }, + { + "cell_type": "markdown", + "id": "b2c3d4e5", + "metadata": {}, + "source": [ + "## 1. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3d4e5f6", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " import google.colab\n", + " !git clone https://github.com/aims-foundations/torch_measure.git\n", + " !pip install -e \"torch_measure[test]\" -q\n", + "except ImportError:\n", + " pass\n", + "\n", + "import sys, types\n", + "sys.modules.setdefault('sentence_transformers',\n", + " types.ModuleType('sentence_transformers'))\n", + "if not hasattr(sys.modules['sentence_transformers'], 'SentenceTransformer'):\n", + " sys.modules['sentence_transformers'].SentenceTransformer = object\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch_measure.models import Rasch, DoublyRobustModel\n", + "from torch_measure.models._predictor import predict_dense\n", + "\n", + "plt.rcParams[\"figure.dpi\"] = 110\n", + "torch.manual_seed(42)\n", + "np.random.seed(42)\n", + "\n", + "print(\"Setup complete.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d4e5f6a7", + "metadata": {}, + "source": [ + "## 2. Generate Sparse Benchmark Data\n", + "\n", + "We simulate a **complete** Rasch response matrix, then apply MNAR missingness:\n", + "high-ability models are less likely to be observed on easy items (mimicking the\n", + "pattern where frontier models skip trivial benchmarks)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5f6a7b8", + "metadata": {}, + "outputs": [], + "source": [ + "n_models, n_items = 60, 80\n", + "\n", + "ability = torch.randn(n_models)\n", + "difficulty = torch.randn(n_items)\n", + "\n", + "logits = ability.unsqueeze(1) - difficulty.unsqueeze(0)\n", + "probs = torch.sigmoid(logits)\n", + "data_full = torch.bernoulli(probs)\n", + "\n", + "# MNAR missingness\n", + "obs_logits = -0.6 * ability.unsqueeze(1) + 0.6 * difficulty.unsqueeze(0)\n", + "obs_probs = torch.sigmoid(obs_logits).clamp(0.15, 0.95)\n", + "obs_mask = torch.bernoulli(obs_probs).bool()\n", + "\n", + "for i in range(n_models):\n", + " if not obs_mask[i].any():\n", + " obs_mask[i, torch.randint(n_items, (1,))] = True\n", + "\n", + "data_sparse = data_full.clone()\n", + "data_sparse[~obs_mask] = float(\"nan\")\n", + "\n", + "obs_rate = obs_mask.float().mean().item()\n", + "print(f\"Response matrix: {n_models} models x {n_items} items\")\n", + "print(f\"Observation rate: {obs_rate:.1%}\")\n", + "print(f\"True mean accuracy: {data_full.mean():.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f6a7b8c9", + "metadata": {}, + "source": [ + "## 3. Fit a Base Rasch Model\n", + "\n", + "First we fit a standard Rasch model on the sparse data. Because the missingness\n", + "is informative, this fit will be biased — ability estimates for high-ability models\n", + "will be pulled down (they're mostly observed on hard items)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7b8c9d0", + "metadata": {}, + "outputs": [], + "source": [ + "base_model = Rasch(n_subjects=n_models, n_items=n_items)\n", + "history = base_model.fit(data_sparse, max_epochs=300, verbose=False)\n", + "\n", + "print(f\"Base model final loss: {history['losses'][-1]:.4f}\")\n", + "\n", + "# Evaluate: how well does the base model recover the full matrix?\n", + "base_preds = predict_dense(base_model).detach()\n", + "base_mse = ((base_preds - data_full) ** 2).mean().item()\n", + "print(f\"Base model MSE on full matrix: {base_mse:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b8c9d0e1", + "metadata": {}, + "source": [ + "## 4. Fit the Doubly Robust Correction\n", + "\n", + "Now we wrap the base model in `DoublyRobustModel` and fit the residual correction.\n", + "The correction is trained with IPW-weighted loss — each observation is weighted by\n", + "`1/propensity`, so the model learns to correct for the selection bias." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c9d0e1f2", + "metadata": {}, + "outputs": [], + "source": [ + "dr_model = DoublyRobustModel(base_model, clip_propensity=(0.05, 0.95))\n", + "dr_history = dr_model.fit(data_sparse, max_epochs=300, verbose=False)\n", + "\n", + "print(f\"DR model final loss: {dr_history['losses'][-1]:.4f}\")\n", + "\n", + "dr_preds = predict_dense(dr_model).detach()\n", + "dr_mse = ((dr_preds - data_full) ** 2).mean().item()\n", + "print(f\"DR model MSE on full matrix: {dr_mse:.4f}\")\n", + "print(f\"Improvement over base: {(base_mse - dr_mse) / base_mse:.1%}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d0e1f2a3", + "metadata": {}, + "source": [ + "## 5. Compare Ability Estimates\n", + "\n", + "The base model's ability estimates are biased because of MNAR. Let's see how the\n", + "DR model's effective abilities (base + correction) compare to the true values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1f2a3b4", + "metadata": {}, + "outputs": [], + "source": [ + "# Per-model mean prediction as a proxy for \"effective ability\"\n", + "base_mean_pred = base_preds.mean(dim=1).numpy()\n", + "dr_mean_pred = dr_preds.mean(dim=1).numpy()\n", + "true_mean = data_full.mean(dim=1).numpy()\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))\n", + "\n", + "axes[0].scatter(true_mean, base_mean_pred, alpha=0.6, s=20)\n", + "axes[0].plot([0, 1], [0, 1], \"k--\", lw=1)\n", + "axes[0].set_xlabel(\"True mean accuracy\")\n", + "axes[0].set_ylabel(\"Predicted mean accuracy\")\n", + "axes[0].set_title(\"Base Rasch Model\")\n", + "\n", + "axes[1].scatter(true_mean, dr_mean_pred, alpha=0.6, s=20, color=\"tab:orange\")\n", + "axes[1].plot([0, 1], [0, 1], \"k--\", lw=1)\n", + "axes[1].set_xlabel(\"True mean accuracy\")\n", + "axes[1].set_ylabel(\"Predicted mean accuracy\")\n", + "axes[1].set_title(\"DoublyRobustModel\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "base_bias = np.abs(base_mean_pred - true_mean).mean()\n", + "dr_bias = np.abs(dr_mean_pred - true_mean).mean()\n", + "print(f\"Mean absolute bias — Base: {base_bias:.4f}, DR: {dr_bias:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f2a3b4c5", + "metadata": {}, + "source": [ + "## 6. Correction Magnitude\n", + "\n", + "How large is the learned correction? We expect it to be small (the base model\n", + "already captures most of the signal) but systematic (correcting the MNAR bias)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3b4c5d6", + "metadata": {}, + "outputs": [], + "source": [ + "correction = (dr_preds - base_preds).numpy()\n", + "\n", + "print(f\"Correction stats:\")\n", + "print(f\" Mean: {correction.mean():.4f}\")\n", + "print(f\" Std: {correction.std():.4f}\")\n", + "print(f\" Range: [{correction.min():.4f}, {correction.max():.4f}]\")\n", + "\n", + "plt.figure(figsize=(6, 3.5))\n", + "plt.hist(correction.ravel(), bins=50, edgecolor=\"white\", alpha=0.7)\n", + "plt.axvline(0, color=\"k\", linestyle=\"--\", lw=1)\n", + "plt.xlabel(\"Correction (DR pred - Base pred)\")\n", + "plt.ylabel(\"Count\")\n", + "plt.title(\"Distribution of DR Correction Term\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b4c5d6e7", + "metadata": {}, + "source": [ + "## 7. Summary\n", + "\n", + "Key findings:\n", + "\n", + "- A standard Rasch model fitted on MNAR-sparse data gives **biased** predictions\n", + " and ability estimates.\n", + "- `DoublyRobustModel` learns a residual correction layer on top of the frozen base,\n", + " trained with IPW-weighted loss to correct for the observation bias.\n", + "- The correction is typically small in magnitude but reduces prediction error on\n", + " the full (unobserved) matrix.\n", + "\n", + "Typical workflow for sparse leaderboard evaluation:\n", + "```python\n", + "from torch_measure.models import Rasch, DoublyRobustModel\n", + "\n", + "base = Rasch(n_subjects=..., n_items=...)\n", + "base.fit(sparse_matrix, method=\"mle\")\n", + "\n", + "dr = DoublyRobustModel(base)\n", + "dr.fit(sparse_matrix, max_epochs=300)\n", + "\n", + "# Dense predictions corrected for observation bias\n", + "predictions = predict_dense(dr)\n", + "```\n", + "\n", + "**References:**\n", + "- Robins, Rotnitzky & Zhao (1994). Estimation of regression coefficients when some\n", + " regressors are not always observed. *JASA*.\n", + "- `torch_measure.models.DoublyRobustModel` API documentation" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 91ebe924280044f3712ede72cc2e244e45046bc5 Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Wed, 3 Jun 2026 13:15:09 -0700 Subject: [PATCH 4/6] fix(lint): sort imports and remove unused numpy in doubly robust --- src/torch_measure/models/__init__.py | 2 +- tests/test_models/test_doubly_robust.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/torch_measure/models/__init__.py b/src/torch_measure/models/__init__.py index f1d8c14..5d535e5 100644 --- a/src/torch_measure/models/__init__.py +++ b/src/torch_measure/models/__init__.py @@ -9,8 +9,8 @@ from torch_measure.models.beta_rasch import BetaRasch from torch_measure.models.beta_twopl import BetaTwoPL from torch_measure.models.bifactor import Bifactor -from torch_measure.models.doubly_robust import DoublyRobustModel from torch_measure.models.bradley_terry import BradleyTerry +from torch_measure.models.doubly_robust import DoublyRobustModel from torch_measure.models.ggm import GaussianGraphicalModel from torch_measure.models.ising import IsingModel from torch_measure.models.llm_judge import LLMJudge diff --git a/tests/test_models/test_doubly_robust.py b/tests/test_models/test_doubly_robust.py index 14abb3b..4c54fe3 100644 --- a/tests/test_models/test_doubly_robust.py +++ b/tests/test_models/test_doubly_robust.py @@ -1,6 +1,5 @@ # Copyright (c) 2026 AIMS Foundations. MIT License. -import numpy as np import torch from torch_measure.models import DoublyRobustModel, Rasch From dff0bd31a0cd14789eb76c27a3f88dfd85ce844f Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Wed, 3 Jun 2026 13:19:57 -0700 Subject: [PATCH 5/6] style: ruff format doubly robust files --- src/torch_measure/models/doubly_robust.py | 39 +++++++++++------------ tests/test_models/test_doubly_robust.py | 10 ++---- 2 files changed, 21 insertions(+), 28 deletions(-) diff --git a/src/torch_measure/models/doubly_robust.py b/src/torch_measure/models/doubly_robust.py index 4df0b36..5709a1f 100644 --- a/src/torch_measure/models/doubly_robust.py +++ b/src/torch_measure/models/doubly_robust.py @@ -53,12 +53,8 @@ def __init__( self._clip_propensity = clip_propensity - self.correction_ability = nn.Parameter( - torch.zeros(n_subjects, device=self._device) - ) - self.correction_difficulty = nn.Parameter( - torch.zeros(n_items, device=self._device) - ) + self.correction_ability = nn.Parameter(torch.zeros(n_subjects, device=self._device)) + self.correction_difficulty = nn.Parameter(torch.zeros(n_items, device=self._device)) self._propensity_weights: torch.Tensor | None = None @@ -68,9 +64,7 @@ def predict(self, query: dict[str, torch.Tensor]) -> torch.Tensor: i = query["item_idx"] base_prob = self._base.predict(query).detach() - correction = torch.sigmoid( - self.correction_ability[s] - self.correction_difficulty[i] - ) - 0.5 + correction = torch.sigmoid(self.correction_ability[s] - self.correction_difficulty[i]) - 0.5 return (base_prob + correction).clamp(1e-7, 1 - 1e-7) @@ -145,19 +139,24 @@ def _estimate_propensity(self, data: torch.Tensor, mask: torch.Tensor) -> None: row_rate = obs.mean(dim=1) col_rate = obs.mean(dim=0) - features = torch.stack([ - row_rate.repeat_interleave(n_i), - col_rate.repeat(n_s), - ], dim=1).numpy() + features = torch.stack( + [ + row_rate.repeat_interleave(n_i), + col_rate.repeat(n_s), + ], + dim=1, + ).numpy() if hasattr(self._base, "ability") and hasattr(self._base, "difficulty"): ability = self._base.ability.detach().cpu() difficulty = self._base.difficulty.detach().cpu() - features = np.hstack([ - features, - ability.repeat_interleave(n_i).numpy()[:, None], - difficulty.repeat(n_s).numpy()[:, None], - ]) + features = np.hstack( + [ + features, + ability.repeat_interleave(n_i).numpy()[:, None], + difficulty.repeat(n_s).numpy()[:, None], + ] + ) y = mask.reshape(-1).numpy().astype(np.int32) @@ -173,9 +172,7 @@ def _estimate_propensity(self, data: torch.Tensor, mask: torch.Tensor) -> None: self._propensity_weights = (1.0 / propensity).to(self._device) - def _get_observation_weights( - self, subject_idx: torch.Tensor, item_idx: torch.Tensor - ) -> torch.Tensor: + def _get_observation_weights(self, subject_idx: torch.Tensor, item_idx: torch.Tensor) -> torch.Tensor: """Look up per-observation IPW weights.""" if self._propensity_weights is None: return torch.ones(subject_idx.shape[0], device=self._device) diff --git a/tests/test_models/test_doubly_robust.py b/tests/test_models/test_doubly_robust.py index 4c54fe3..8e7d002 100644 --- a/tests/test_models/test_doubly_robust.py +++ b/tests/test_models/test_doubly_robust.py @@ -35,7 +35,6 @@ def _make_sparse_rasch( class TestDoublyRobustModel: - def test_init_freezes_base(self): base = Rasch(n_subjects=10, n_items=20) dr = DoublyRobustModel(base) @@ -103,9 +102,7 @@ def test_base_params_unchanged_after_fit(self): def test_improves_prediction_on_sparse_data(self): """DR model should predict held-out cells better than base alone.""" torch.manual_seed(42) - data_sparse, data_full, ability, difficulty = _make_sparse_rasch( - n_subjects=60, n_items=40, seed=11 - ) + data_sparse, data_full, ability, difficulty = _make_sparse_rasch(n_subjects=60, n_items=40, seed=11) base = Rasch(n_subjects=60, n_items=40) base.fit(data_sparse, max_epochs=200, verbose=False) @@ -121,9 +118,7 @@ def test_improves_prediction_on_sparse_data(self): dr_mse = ((dr_preds - data_full) ** 2).mean().item() # DR should not be substantially worse - assert dr_mse < base_mse + 0.02, ( - f"DR MSE {dr_mse:.4f} much worse than base {base_mse:.4f}" - ) + assert dr_mse < base_mse + 0.02, f"DR MSE {dr_mse:.4f} much worse than base {base_mse:.4f}" def test_propensity_clipping(self): data_sparse, _, _, _ = _make_sparse_rasch(20, 15, seed=13) @@ -160,5 +155,6 @@ def test_forward_equals_predict(self): base = Rasch(n_subjects=10, n_items=20) dr = DoublyRobustModel(base) from torch_measure.models._predictor import cartesian_query + query = cartesian_query(10, 20) torch.testing.assert_close(dr(query), dr.predict(query)) From 0dc0a8ec5f4ea41ac2f8829cb30ae8b145fbcef1 Mon Sep 17 00:00:00 2001 From: Pranil Raichura Date: Wed, 3 Jun 2026 13:42:25 -0700 Subject: [PATCH 6/6] docs(tutorials): clean up DoublyRobustModel notebook with outputs --- .../doubly_robust_sparse_benchmarks.ipynb | 337 +++++++++--------- 1 file changed, 163 insertions(+), 174 deletions(-) diff --git a/tutorials/doubly_robust_sparse_benchmarks.ipynb b/tutorials/doubly_robust_sparse_benchmarks.ipynb index a7426b3..dac2e0c 100644 --- a/tutorials/doubly_robust_sparse_benchmarks.ipynb +++ b/tutorials/doubly_robust_sparse_benchmarks.ipynb @@ -7,24 +7,11 @@ "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/aims-foundations/torch_measure/blob/main/tutorials/doubly_robust_sparse_benchmarks.ipynb)\n", "\n", - "# Doubly Robust Model for Sparse Benchmark Matrices\n", + "# DoublyRobustModel for Sparse Benchmarks\n", "\n", - "AI benchmark leaderboards are rarely complete: not every model is evaluated on every task.\n", - "When this missingness is informative — e.g. frontier models are evaluated only on hard\n", - "benchmarks, or cheap models skip expensive evaluations — a naive IRT fit is biased.\n", - "\n", - "The **DoublyRobustModel** corrects for this by learning a residual correction on top of\n", - "a base IRT model, trained with inverse-propensity-weighted (IPW) loss:\n", - "\n", - " final_prediction(i, j) = base_model(i, j) + correction(i, j)\n", - "\n", - "The propensity weighting during training ensures the correction compensates for\n", - "the observation bias, making predictions consistent even under MNAR.\n", - "\n", - "This tutorial demonstrates:\n", - "1. How informative missingness biases a naive Rasch fit\n", - "2. How `DoublyRobustModel` learns a bias-correcting residual\n", - "3. Comparing dense predictions between the base and DR model" + "When benchmark response matrices have informative missingness (MNAR), a standard IRT fit is biased.\n", + "`DoublyRobustModel` wraps a fitted base model and learns a residual correction trained with\n", + "inverse-propensity-weighted loss to correct for the observation bias." ] }, { @@ -32,41 +19,42 @@ "id": "b2c3d4e5", "metadata": {}, "source": [ - "## 1. Setup" + "## Setup" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "c3d4e5f6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T20:40:30.119988Z", + "iopub.status.busy": "2026-06-03T20:40:30.119914Z", + "iopub.status.idle": "2026-06-03T20:40:33.533891Z", + "shell.execute_reply": "2026-06-03T20:40:33.533212Z" + } + }, "outputs": [], "source": [ - "try:\n", - " import google.colab\n", - " !git clone https://github.com/aims-foundations/torch_measure.git\n", - " !pip install -e \"torch_measure[test]\" -q\n", - "except ImportError:\n", - " pass\n", + "import sys\n", + "import types\n", "\n", - "import sys, types\n", - "sys.modules.setdefault('sentence_transformers',\n", - " types.ModuleType('sentence_transformers'))\n", - "if not hasattr(sys.modules['sentence_transformers'], 'SentenceTransformer'):\n", - " sys.modules['sentence_transformers'].SentenceTransformer = object\n", + "# Mock sentence_transformers to avoid import deadlock on macOS\n", + "sys.modules.setdefault(\"sentence_transformers\", types.ModuleType(\"sentence_transformers\"))\n", + "if not hasattr(sys.modules[\"sentence_transformers\"], \"SentenceTransformer\"):\n", + " sys.modules[\"sentence_transformers\"].SentenceTransformer = object\n", "\n", - "import numpy as np\n", - "import torch\n", - "import matplotlib.pyplot as plt\n", + "import matplotlib.pyplot as plt # noqa: E402\n", + "import numpy as np # noqa: E402\n", + "import torch # noqa: E402\n", "\n", - "from torch_measure.models import Rasch, DoublyRobustModel\n", - "from torch_measure.models._predictor import predict_dense\n", + "from torch_measure.models import DoublyRobustModel, Rasch # noqa: E402\n", + "from torch_measure.models._predictor import predict_dense # noqa: E402\n", "\n", - "plt.rcParams[\"figure.dpi\"] = 110\n", - "torch.manual_seed(42)\n", - "np.random.seed(42)\n", + "# !pip install torch_measure # uncomment if running on Colab\n", "\n", - "print(\"Setup complete.\")" + "plt.rcParams[\"figure.dpi\"] = 110\n", + "torch.manual_seed(42);" ] }, { @@ -74,45 +62,53 @@ "id": "d4e5f6a7", "metadata": {}, "source": [ - "## 2. Generate Sparse Benchmark Data\n", + "## Data\n", "\n", - "We simulate a **complete** Rasch response matrix, then apply MNAR missingness:\n", - "high-ability models are less likely to be observed on easy items (mimicking the\n", - "pattern where frontier models skip trivial benchmarks)." + "We generate a complete Rasch response matrix, then apply MNAR missingness: high-ability\n", + "models are less likely observed on easy items (frontier models skip trivial benchmarks)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e5f6a7b8", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T20:40:33.535567Z", + "iopub.status.busy": "2026-06-03T20:40:33.535390Z", + "iopub.status.idle": "2026-06-03T20:40:33.571924Z", + "shell.execute_reply": "2026-06-03T20:40:33.571682Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "40 models x 50 items, 48% observed\n" + ] + } + ], "source": [ - "n_models, n_items = 60, 80\n", - "\n", - "ability = torch.randn(n_models)\n", - "difficulty = torch.randn(n_items)\n", + "n_models, n_items = 40, 50\n", "\n", + "ability = torch.randn(n_models) * 1.5\n", + "difficulty = torch.randn(n_items) * 1.5\n", "logits = ability.unsqueeze(1) - difficulty.unsqueeze(0)\n", - "probs = torch.sigmoid(logits)\n", - "data_full = torch.bernoulli(probs)\n", + "data_full = torch.bernoulli(torch.sigmoid(logits))\n", "\n", - "# MNAR missingness\n", - "obs_logits = -0.6 * ability.unsqueeze(1) + 0.6 * difficulty.unsqueeze(0)\n", - "obs_probs = torch.sigmoid(obs_logits).clamp(0.15, 0.95)\n", + "# MNAR: P(observed) depends on ability and difficulty\n", + "obs_logits = -1.2 * ability.unsqueeze(1) + 1.2 * difficulty.unsqueeze(0)\n", + "obs_probs = torch.sigmoid(obs_logits).clamp(0.08, 0.75)\n", "obs_mask = torch.bernoulli(obs_probs).bool()\n", - "\n", "for i in range(n_models):\n", " if not obs_mask[i].any():\n", - " obs_mask[i, torch.randint(n_items, (1,))] = True\n", + " obs_mask[i, 0] = True\n", "\n", "data_sparse = data_full.clone()\n", "data_sparse[~obs_mask] = float(\"nan\")\n", "\n", - "obs_rate = obs_mask.float().mean().item()\n", - "print(f\"Response matrix: {n_models} models x {n_items} items\")\n", - "print(f\"Observation rate: {obs_rate:.1%}\")\n", - "print(f\"True mean accuracy: {data_full.mean():.3f}\")" + "print(f\"{n_models} models x {n_items} items, {obs_mask.float().mean():.0%} observed\")" ] }, { @@ -120,29 +116,39 @@ "id": "f6a7b8c9", "metadata": {}, "source": [ - "## 3. Fit a Base Rasch Model\n", + "## Base Model\n", "\n", - "First we fit a standard Rasch model on the sparse data. Because the missingness\n", - "is informative, this fit will be biased — ability estimates for high-ability models\n", - "will be pulled down (they're mostly observed on hard items)." + "Fit a standard Rasch model on the sparse data. The MNAR pattern biases the ability estimates." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a7b8c9d0", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T20:40:33.573105Z", + "iopub.status.busy": "2026-06-03T20:40:33.573023Z", + "iopub.status.idle": "2026-06-03T20:40:33.655304Z", + "shell.execute_reply": "2026-06-03T20:40:33.655068Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Base MSE on full matrix: 0.1703\n" + ] + } + ], "source": [ - "base_model = Rasch(n_subjects=n_models, n_items=n_items)\n", - "history = base_model.fit(data_sparse, max_epochs=300, verbose=False)\n", - "\n", - "print(f\"Base model final loss: {history['losses'][-1]:.4f}\")\n", + "base = Rasch(n_subjects=n_models, n_items=n_items)\n", + "base.fit(data_sparse, max_epochs=200, verbose=False)\n", "\n", - "# Evaluate: how well does the base model recover the full matrix?\n", - "base_preds = predict_dense(base_model).detach()\n", + "base_preds = predict_dense(base).detach()\n", "base_mse = ((base_preds - data_full) ** 2).mean().item()\n", - "print(f\"Base model MSE on full matrix: {base_mse:.4f}\")" + "print(f\"Base MSE on full matrix: {base_mse:.4f}\")" ] }, { @@ -150,29 +156,41 @@ "id": "b8c9d0e1", "metadata": {}, "source": [ - "## 4. Fit the Doubly Robust Correction\n", + "## DR Correction\n", "\n", - "Now we wrap the base model in `DoublyRobustModel` and fit the residual correction.\n", - "The correction is trained with IPW-weighted loss — each observation is weighted by\n", - "`1/propensity`, so the model learns to correct for the selection bias." + "Wrap the base in `DoublyRobustModel` and fit the correction layer." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "c9d0e1f2", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T20:40:33.656668Z", + "iopub.status.busy": "2026-06-03T20:40:33.656590Z", + "iopub.status.idle": "2026-06-03T20:40:33.733110Z", + "shell.execute_reply": "2026-06-03T20:40:33.732849Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DR MSE on full matrix: 0.1448\n", + "Improvement: 14.9%\n" + ] + } + ], "source": [ - "dr_model = DoublyRobustModel(base_model, clip_propensity=(0.05, 0.95))\n", - "dr_history = dr_model.fit(data_sparse, max_epochs=300, verbose=False)\n", - "\n", - "print(f\"DR model final loss: {dr_history['losses'][-1]:.4f}\")\n", + "dr = DoublyRobustModel(base, clip_propensity=(0.05, 0.95))\n", + "dr.fit(data_sparse, max_epochs=200, verbose=False)\n", "\n", - "dr_preds = predict_dense(dr_model).detach()\n", + "dr_preds = predict_dense(dr).detach()\n", "dr_mse = ((dr_preds - data_full) ** 2).mean().item()\n", - "print(f\"DR model MSE on full matrix: {dr_mse:.4f}\")\n", - "print(f\"Improvement over base: {(base_mse - dr_mse) / base_mse:.1%}\")" + "print(f\"DR MSE on full matrix: {dr_mse:.4f}\")\n", + "print(f\"Improvement: {(base_mse - dr_mse) / base_mse:.1%}\")" ] }, { @@ -180,44 +198,70 @@ "id": "d0e1f2a3", "metadata": {}, "source": [ - "## 5. Compare Ability Estimates\n", - "\n", - "The base model's ability estimates are biased because of MNAR. Let's see how the\n", - "DR model's effective abilities (base + correction) compare to the true values." + "## Results" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e1f2a3b4", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-06-03T20:40:33.735731Z", + "iopub.status.busy": "2026-06-03T20:40:33.735510Z", + "iopub.status.idle": "2026-06-03T20:40:33.935450Z", + "shell.execute_reply": "2026-06-03T20:40:33.934893Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean abs bias: Base 0.1103, DR 0.0562\n" + ] + } + ], "source": [ - "# Per-model mean prediction as a proxy for \"effective ability\"\n", - "base_mean_pred = base_preds.mean(dim=1).numpy()\n", - "dr_mean_pred = dr_preds.mean(dim=1).numpy()\n", "true_mean = data_full.mean(dim=1).numpy()\n", + "base_mean = base_preds.mean(dim=1).numpy()\n", + "dr_mean = dr_preds.mean(dim=1).numpy()\n", "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))\n", + "fig, axes = plt.subplots(1, 3, figsize=(13, 4))\n", "\n", - "axes[0].scatter(true_mean, base_mean_pred, alpha=0.6, s=20)\n", + "axes[0].scatter(true_mean, base_mean, alpha=0.6, s=20)\n", "axes[0].plot([0, 1], [0, 1], \"k--\", lw=1)\n", "axes[0].set_xlabel(\"True mean accuracy\")\n", - "axes[0].set_ylabel(\"Predicted mean accuracy\")\n", - "axes[0].set_title(\"Base Rasch Model\")\n", + "axes[0].set_ylabel(\"Predicted\")\n", + "axes[0].set_title(\"Base Rasch\")\n", "\n", - "axes[1].scatter(true_mean, dr_mean_pred, alpha=0.6, s=20, color=\"tab:orange\")\n", + "axes[1].scatter(true_mean, dr_mean, alpha=0.6, s=20, color=\"tab:orange\")\n", "axes[1].plot([0, 1], [0, 1], \"k--\", lw=1)\n", "axes[1].set_xlabel(\"True mean accuracy\")\n", - "axes[1].set_ylabel(\"Predicted mean accuracy\")\n", + "axes[1].set_ylabel(\"Predicted\")\n", "axes[1].set_title(\"DoublyRobustModel\")\n", "\n", + "correction = (dr_preds - base_preds).numpy().ravel()\n", + "axes[2].hist(correction, bins=50, edgecolor=\"white\", alpha=0.7)\n", + "axes[2].axvline(0, color=\"k\", linestyle=\"--\", lw=1)\n", + "axes[2].set_xlabel(\"Correction (DR - Base)\")\n", + "axes[2].set_ylabel(\"Count\")\n", + "axes[2].set_title(\"Correction Distribution\")\n", + "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", - "base_bias = np.abs(base_mean_pred - true_mean).mean()\n", - "dr_bias = np.abs(dr_mean_pred - true_mean).mean()\n", - "print(f\"Mean absolute bias — Base: {base_bias:.4f}, DR: {dr_bias:.4f}\")" + "print(f\"Mean abs bias: Base {np.abs(base_mean - true_mean).mean():.4f}, DR {np.abs(dr_mean - true_mean).mean():.4f}\")" ] }, { @@ -225,70 +269,7 @@ "id": "f2a3b4c5", "metadata": {}, "source": [ - "## 6. Correction Magnitude\n", - "\n", - "How large is the learned correction? We expect it to be small (the base model\n", - "already captures most of the signal) but systematic (correcting the MNAR bias)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a3b4c5d6", - "metadata": {}, - "outputs": [], - "source": [ - "correction = (dr_preds - base_preds).numpy()\n", - "\n", - "print(f\"Correction stats:\")\n", - "print(f\" Mean: {correction.mean():.4f}\")\n", - "print(f\" Std: {correction.std():.4f}\")\n", - "print(f\" Range: [{correction.min():.4f}, {correction.max():.4f}]\")\n", - "\n", - "plt.figure(figsize=(6, 3.5))\n", - "plt.hist(correction.ravel(), bins=50, edgecolor=\"white\", alpha=0.7)\n", - "plt.axvline(0, color=\"k\", linestyle=\"--\", lw=1)\n", - "plt.xlabel(\"Correction (DR pred - Base pred)\")\n", - "plt.ylabel(\"Count\")\n", - "plt.title(\"Distribution of DR Correction Term\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "b4c5d6e7", - "metadata": {}, - "source": [ - "## 7. Summary\n", - "\n", - "Key findings:\n", - "\n", - "- A standard Rasch model fitted on MNAR-sparse data gives **biased** predictions\n", - " and ability estimates.\n", - "- `DoublyRobustModel` learns a residual correction layer on top of the frozen base,\n", - " trained with IPW-weighted loss to correct for the observation bias.\n", - "- The correction is typically small in magnitude but reduces prediction error on\n", - " the full (unobserved) matrix.\n", - "\n", - "Typical workflow for sparse leaderboard evaluation:\n", - "```python\n", - "from torch_measure.models import Rasch, DoublyRobustModel\n", - "\n", - "base = Rasch(n_subjects=..., n_items=...)\n", - "base.fit(sparse_matrix, method=\"mle\")\n", - "\n", - "dr = DoublyRobustModel(base)\n", - "dr.fit(sparse_matrix, max_epochs=300)\n", - "\n", - "# Dense predictions corrected for observation bias\n", - "predictions = predict_dense(dr)\n", - "```\n", - "\n", - "**References:**\n", - "- Robins, Rotnitzky & Zhao (1994). Estimation of regression coefficients when some\n", - " regressors are not always observed. *JASA*.\n", - "- `torch_measure.models.DoublyRobustModel` API documentation" + "See `torch_measure.models.DoublyRobustModel` for the full API." ] } ], @@ -299,8 +280,16 @@ "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "version": "3.10.0" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" } }, "nbformat": 4,