💻 computer science

Training as Treatment: A Causal Framework for Machine-Learning Evaluation

This paper introduces "Training as Treatment," a causal framework that models data-role assignments and pipeline choices as interventions to rigorously analyze machine-learning evaluation metrics, accounting for model-induced interference and enabling more robust diagnostics for fairness, leakage, and generalization.

Original authors: Vikas Ramachandra

Published 2026-08-10

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Vikas Ramachandra

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Hidden Handshake of Machine Learning

Imagine you are trying to teach a robot to recognize cats. You show it thousands of pictures, and it learns by adjusting its internal "brain" settings. In the world of computer science, this is called machine learning. But here is the tricky part: how do we know if the robot is actually smart, or if it just memorized the specific pictures you showed it? Usually, scientists split their data into two piles: a "training" pile to teach the robot, and a "test" pile to check its work.

For a long time, researchers treated this split as a simple, boring administrative step—like sorting laundry into "whites" and "darks." They assumed the test pile was just a neutral mirror, reflecting the robot's true ability without changing it. However, a new way of thinking suggests that the way we sort this data is actually a powerful force that shapes the robot's brain. This idea comes from a field called causal inference, which is basically the science of figuring out what causes what. Instead of just watching things happen, causal inference asks: "If I had done things differently, what would have changed?" In the context of AI, this means asking: "If I had moved this specific picture from the 'teach' pile to the 'test' pile, would the robot's brain have changed, and would its final score be different?"

This is exactly the question a researcher named Vikas Ramachandra tackles in a new paper titled "Training as Treatment." The paper argues that we need to stop treating the training process as a passive routine and start treating it like a medical experiment. Just as a doctor gives a patient a specific medicine to see if it cures a disease, we should view the act of feeding data to a machine as a "treatment" that actively changes the outcome.

The Robot's Shared Brain

The core idea of Ramachandra's paper is simple but revolutionary: The robot's brain is a shared space. When you teach the robot with one specific picture, that picture doesn't just stay in the "training" pile; it changes the robot's brain for every single other picture it will ever see.

Think of it like a classroom of students studying for a big exam. If one student (let's call him "Data Point A") learns a clever trick to solve a math problem, and the teacher (the algorithm) uses that trick to help the whole class, then every other student benefits. But if "Data Point A" learns a wrong trick, the whole class might get confused. In traditional machine learning, we often pretend that the student who took the test (the "test set") is completely separate from the students who studied (the "training set"). Ramachandra says this is a lie. The test student is taking the exam based on a brain that was shaped by the training students. Therefore, moving a picture from the training pile to the test pile isn't just moving a file; it's like removing a student from the study group and putting them on the exam. This changes the brain of the remaining students and changes who is taking the test.

The "Training as Treatment" Experiment

Ramachandra proposes a new framework called "Training as Treatment." Instead of just running a model once and getting a score, he suggests we should run thousands of tiny experiments to see exactly what each piece of data does.

He breaks down the process into different "roles" for the data:

Fitting: The data used to teach the robot.
Validation: The data used to tweak the robot's settings (like deciding how hard to study).
Evaluation: The data used to give the final grade.
Audit: A special, untouched group of data used to check if the robot is truly fair and accurate, without ever letting the robot see it during training.

The paper introduces a concept called interference. In simple terms, this means that what happens to one data point affects all the others. If you include a specific picture in the training set, it might make the robot better at recognizing cats (a "positive spillover"), or it might make the robot worse at recognizing dogs because it got confused (a "negative spillover").

To measure this, the author suggests a few clever ways to experiment:

The Randomized Inclusion: Imagine flipping a coin for every single picture in your collection. If it's heads, the robot studies it; if it's tails, the robot ignores it. By doing this thousands of times, you can see exactly how much that one picture helps or hurts the robot's final score.
The Paired Swap: Imagine taking two pictures, Picture A and Picture B. You train the robot with A but not B, then swap them and train with B but not A. By comparing the results, you can see which picture is actually more valuable.

What the Experiments Showed

The paper doesn't just talk about theory; it ran actual experiments to test these ideas. The researchers used real-world datasets (like medical records for breast cancer and wine quality) and created fake datasets with known problems (like pictures with wrong labels or hidden tricks).

Here is what they found:

1. The "Split" is a Trickster
The most surprising finding is that the way you split your data (the "split policy") acts like a magic switch that changes the robot's score, even if the robot's brain stays exactly the same.

In their simulations, simply changing how they divided the data caused the robot's accuracy score (called AUC) to jump or drop by as much as 0.257.
For example, in a simulation with noisy (messy) data, using a "cluster holdout" split (where similar items are grouped together) made the robot look much worse than using a standard random split. This proves that the "test score" isn't just a measure of how smart the robot is; it's also a measure of how the test was designed.

2. Not All Data is Created Equal
The experiments showed that some pictures are "memorized" by the robot but don't actually help it learn.

They found that removing certain training pictures actually improved the robot's performance on other pictures. This means those pictures were harmful or redundant.
Conversely, removing other pictures made the robot worse, proving they were helpful.
The paper suggests that a picture can be "memorized" (the robot remembers it perfectly) but still be "harmful" to the robot's ability to generalize to new situations.

3. Algorithms are Picky Eaters
The researchers tested two different types of robot brains: a "Logistic Regression" (a simpler, straight-line thinker) and a "Random Forest" (a more complex, tree-branch thinker).

They found that the "best" robot depends entirely on the situation. In a clean, simple simulation, the Random Forest was much better. But on a real-world breast cancer dataset, the simpler Logistic Regression was actually better or just as good.
This means you can't just say "Algorithm X is the best." You have to say "Algorithm X is the best for this specific type of data and this specific way of splitting it."

4. The "Audit" is the Truth-Teller
The paper emphasizes the need for an "audit" set—a group of data that the robot never sees until the very end.

They found that if you use the test data to tweak your settings (like changing the robot's difficulty level), you might get a high score that is fake.
By keeping a separate "audit" group, they could see that some split policies made the robot look great on the test but actually perform poorly on the audit. This helps catch "leakage," where the robot accidentally learns from the test data it shouldn't know.

The Big Picture

Ramachandra's paper suggests that we need to stop looking at machine learning as a one-way street where data goes in and a score comes out. Instead, we should see it as a complex web of interactions where every piece of data influences every other piece.

The main takeaway is that the way we train and test our AI is a causal intervention. It's not just a measurement tool; it's an active part of the experiment that shapes the result. By treating training as a "treatment" and using these new experimental methods, we can finally answer questions like: "Is this specific picture actually helping the AI, or is it just memorizing?" and "Is this high score real, or did we just get lucky with how we split the data?"

The paper doesn't claim to have solved all of AI's problems. It admits that doing these experiments is expensive and computationally heavy. However, it provides a new map and a new set of tools to navigate the messy reality of machine learning, helping us distinguish between a robot that truly learned and one that just got lucky.

Technical Summary: Training as Treatment: A Causal Framework for Machine-Learning Evaluation

1. Problem Statement

Conventional machine learning evaluation treats the assignment of data to training, validation, and test sets as a procedural step rather than an object of causal analysis. This paper argues that the standard train-test gap is not a clean causal estimand because it conflates multiple distinct interventions: the effect of an observation on model fitting, the effect of model selection (via validation), and the effect of measurement composition (via the test set).

Furthermore, standard evaluation ignores interference: because a single fitted model is shared across all targets, the inclusion or exclusion of one observation changes the predictions for all other observations. Existing methods like influence functions, Data Shapley, and algorithmic stability address specific aspects of data sensitivity or contribution but fail to integrate data roles, model selection, split policies, and interference into a unified causal meta-evaluation system.

2. Methodology: The "Training as Treatment" Framework

The paper proposes a potential-outcomes framework where data-role assignments and learning-pipeline choices are modeled as interventions.

2.1 Formal Setup

Units: Candidate observations ( $O_i$ ), groups, or datasets.
Treatments:
- Data Roles: Each observation is assigned one of five roles: Fitting ( $F$ ), Validation ( $V$ ), Evaluation ( $E$ ), Auditing ( $A$ ), or Unused ( $U$ ).
- Pipeline Interventions: Algorithm ( $a$ ), hyperparameters ( $h$ ), random seed ( $s$ ), curriculum ( $c$ ), weights ( $w$ ), and training order ( $o$ ).
Outcomes: Potential predictions, point-level losses, aggregate metrics (e.g., AUC, fairness), calibration, and robustness on a fixed, untouched audit population.

2.2 Key Causal Concepts

Interference: The fitted model acts as a shared mechanism. The potential outcome for target $j$ depends on the entire training assignment vector, not just its own assignment.
Clean Evaluation: A crucial distinction is made that assigning a point to a "clean" test set (never consulted during fitting or selection) does not change the learned model; it only changes where performance is measured.
Exposure Mapping: To handle the complexity of unrestricted interference (where outcomes depend on $2^n$ assignments), the framework uses low-dimensional exposure mappings (e.g., based on similarity, group membership, or gradient alignment) to summarize peer assignments.

2.3 Causal Estimands

The framework defines several specific estimands:

Self-Inclusion Effect: The change in loss on an observation $i$ when it is included in training versus withheld (memorization vs. generalization).
Cross-Observation Spillover: The effect of including observation $i$ on the loss of a different target $j$ . This constructs a "causal training-influence network."
Audit-Generalization Effect: The effect of including $i$ on the performance of a fixed, external audit population.
Split-Policy Effects: The causal impact of different data-splitting strategies (e.g., IID, temporal, clustered) on audit performance.
Interaction Effects: How the value of a data point depends on the specific algorithm or regularization regime used.

2.4 Experimental Designs

To identify these effects, the paper proposes:

Randomized-Subset Designs: Independently assigning observations to fitting with a known probability while holding a permanent audit set untouched.
Fixed-Size Paired-Swap Designs: Replacing one training point with another while keeping the rest of the set fixed to estimate marginal effects.
Factorial Pipeline Experiments: Crossing data-role assignments with algorithms, seeds, and augmentation policies to estimate interactions.

3. Key Contributions

Unified Causal Formulation: Separates fitting, validation, evaluation, and auditing into distinct causal stages, distinguishing the effect of learning from an observation from the effect of measuring performance on it.
Interference-Aware Modeling: Explicitly models the fitted model as a source of interference, allowing for the estimation of spillover effects and the construction of causal influence graphs.
New Estimands: Introduces metrics for self-inclusion, cross-observation spillover, audit-generalization, and split-policy effects, moving beyond simple error estimation.
Diagnostic Tools: Provides a basis for causal cross-validation, leakage diagnostics (detecting if a test set inadvertently influenced training), and fairness spillover analysis.
Estimators: Develops design-based estimators (difference-in-means, Horvitz-Thompson), sparse factorial regression, and low-rank/graph-regularized estimators for influence networks.

4. Empirical Results

The paper presents experimental results using real datasets (Breast Cancer Wisconsin, Wine) and controlled simulations (clean, label noise, imbalanced with spurious features).

Split Policy as an Intervention: Changing the split policy (e.g., from stratified IID to cluster holdout or feature-tail holdout) caused systematic, large shifts in reported AUC. In simulations, cluster holdout reduced AUC by ~0.20 for logistic regression, while feature-tail splits had varying impacts depending on the data regime. This demonstrates that the evaluation protocol is an active intervention, not a neutral measurement device.
Algorithm Heterogeneity: The superiority of an algorithm (e.g., Random Forest vs. Logistic Regression) was highly conditional on the split policy and data regime. Random Forest outperformed Logistic Regression in nonlinear and noisy settings but performed worse on the real Breast Cancer dataset under cluster holdout.
Variance Decomposition: In simulations with structured data, the split policy accounted for the largest fraction of AUC variation (up to 59%), often exceeding the variance explained by model choice or random seeds.
Point-Level Interference: In a point-inclusion experiment on the Breast Cancer dataset, removing individual training points caused measurable changes in log loss on a fixed test set. Some removals increased loss (indicating helpful inclusion), while others decreased loss (indicating harmful or redundant inclusion), empirically confirming interference.

5. Significance and Claims

The paper claims that "Training as Treatment" reframes the machine learning pipeline as a causal experiment. Its primary significance lies in:

Clarifying the Generalization Gap: It shows that the observed train-test gap is a mixture of self-inclusion effects, train-test composition, peer exposure, and model selection decisions, and thus cannot be interpreted as a pure measure of overfitting.
Distinguishing Memorization from Transfer: By separating self-inclusion effects from audit-generalization effects, the framework helps identify when a model is merely memorizing data versus learning transferable patterns.
Evaluating Evaluation: It provides a causal basis for diagnosing whether reported performance improvements are due to better learning or simply "easier" test samples resulting from favorable split policies or selection biases.
Intervention-Aware Data Acquisition: It offers a theoretical foundation for acquiring data based on causal audit effects rather than heuristic quality scores, acknowledging that data value is relative to the learner, the split policy, and the audit population.

The author maintains a modest stance, noting that exact retraining is expensive, interference mapping is complex, and the framework requires careful experimental design (e.g., locked audit sets) to avoid confounding. The proposed framework serves as a diagnostic and estimation tool rather than a replacement for all existing evaluation practices.