CURED: Creating, Understanding, and Repairing Errors Demonstrator

Source: arXiv:2607.20140 · Published 2026-07-22 · By Nicholas Chandler, Sebastian Jäger, Philipp Jung, Felix Bießmann

TL;DR

This work introduces CURED, a unified web-based demonstrator designed to bridge the gap between advanced machine learning (ML) research on tabular data error modeling, detection, and cleaning and practical user intuition. CURED allows users to upload tabular datasets, inject realistic, data-dependent errors using a parametrizable error generator (tab-err), clean these errors using an ML-based conformal data cleaning method (CDC), and analyze error generation mechanisms with a dedicated detection algorithm (MechDetect). This pipeline integrates recent theoretical advances in error modeling, conformal prediction for uncertainty calibrated cleaning, and error mechanism inference into an interactive interface aimed at practitioners and researchers alike.

The system combines three main components: the tab-err error injection library models errors via error type, location dependence (error mechanism), and rate; CDC leverages per-column ML imputation models with conformal prediction to detect and correct errors while providing statistically rigorous confidence guarantees; and MechDetect classifies injected error mechanisms by comparing model performances on error mask prediction. Empirical evaluation reports median detection true positive rates around 65% with false positive rates ~0.006 across different error mechanisms, and MechDetect achieves accuracy above 90% for certain error types and mechanisms across numeric and categorical columns. The open-source, extensible demonstrator offers a valuable tool to understand and experiment with realistic error scenarios and ML-based cleaning on tabular data.

Key findings

• Conformal Data Cleaning (CDC) achieves an error detection true positive rate (TPR) around 65% and a low false positive rate (FPR) near 0.0065 across different error mechanisms (ECAR, EAR, ENAR) (Table 2).
• CDC yields downstream improvement (DSI) in predictive task performance of up to 3.5% depending on the error mechanism, with EAR showing highest gain (0.0349) (Table 2).
• MechDetect achieves classification accuracies above 92% for ECAR and EAR in both numeric and categorical columns, but lower accuracy (~70-73%) for ENAR, indicating difficulty detecting certain data-dependent errors (Table 3).
• The tab-err error generator parametrizes error scenarios via separate error types, mechanisms, and rates, offering fine-grained control over realistic error injections.
• The error mechanisms follow a taxonomy inspired by Rubin's missing data theory: Errors Completely At Random (ECAR), Errors At Random (EAR) dependent on other columns, and Errors Not At Random (ENAR) dependent on the same column.
• CDC cleaning operates by detecting errors via conformal prediction sets on imputation ML models per column, masking detected errors as missing and imputing corrected values.
• The demonstrator supports user upload of datasets with up to 10 columns and 10,000 rows, splitting data 80/20 for training and evaluation, enabling practical experimentation with error scenarios.
• Integration of tab-err, CDC, and MechDetect into one web application offers an interactive platform to intuitively explore ML-based error modeling, detection, repair, and understanding.

Threat model

The system assumes a benign setting where data errors arise naturally or are synthetically injected according to probabilistic error mechanisms rather than intentional adversarial tampering. The adversary is not active and does not seek to evade detection or deliberately distort data. The focus is on characterizing and correcting stochastic data errors rather than defending against malicious attackers.

Methodology — deep read

1. Threat model & assumptions: The system assumes an adversarial-free setting where errors in tabular data arise according to probabilistic models rather than active attackers. The focus is on detecting and repairing naturally occurring or realistically simulated data errors that can be completely random (ECAR), dependent on other observed columns (EAR), or dependent on the same column (ENAR). There is no explicit adversarial capability assumed.

2. Data provenance and splits: Users upload arbitrary tabular datasets or choose predefined ones such as the nuclear power plant dataset from OpenML (ID 44969). Datasets must have fewer than 10 columns, fewer than 10,000 rows, and a designated target column for downstream ML tasks. Data is split into 80% training for the conformal cleaner and downstream models, and 20% held-out for error injection and evaluation.

3. Architecture / algorithms: The pipeline consists of three integrated components:

• tab-err error injection library that models errors by separating error type (how a cell is altered, e.g., typo, unit conversion), error mechanism (distribution of error locations: ECAR, EAR, ENAR), and error rate (proportion of cells affected).
• Conformal Data Cleaning (CDC): For each column, an ML model (e.g., gradient boosted trees) is trained to impute that column’s values from the others. Conformal prediction calibrates uncertainty, producing per-cell prediction sets at confidence level 1-α, determining if the current value lies within the plausible set. Cells outside the set are flagged as erroneous and replaced by the model’s predicted value.
• MechDetect: A diagnostic algorithm that compares ML model performances on predicting error masks to infer which error mechanism generated perturbations. It uses statistical testing to yield predicted mechanism labels (ECAR, EAR, ENAR) alongside p-values.

4. Training regime: The ML models use standard training procedures for tabular data models; specific hyperparameters are not detailed but likely involve GBDT frameworks like CatBoost. Experiments fix a high confidence level α=0.001 for CDC. Training occurs on the 80% training split, with evaluation on held-out data.

5. Evaluation protocol: Error detection performance is measured via True Positive Rate and False Positive Rate of detecting erroneous cells. Downstream Improvement (DSI) quantifies improvement in predictive task accuracy after cleaning relative to perturbed data. MechDetect accuracy is measured as the fraction of correctly identified error mechanisms over multiple scenarios and datasets. Evaluations are reported as medians over balanced sets of error rates and mechanisms.

6. Reproducibility: All code components are open source under permissive licenses available via GitHub. The web demo hosts integration of tab-err, CDC, and MechDetect. The study uses public datasets such as OpenML-44969 where applicable. Frozen weights are not discussed, as models are trained per dataset in demo runs.

Example workflow: A user uploads a numeric tabular dataset with a target column, chooses an error rate and mechanism (e.g. EAR with 10% errors), triggers tab-err to inject errors (like unit errors or typos), runs CDC at 0.999 confidence to detect and impute erroneous values, and then invokes MechDetect to identify that errors primarily depend on other columns. This allows inspection of error locations, cleaned data quality, and characterization of error generation models in one interface.

Technical innovations

• Integration of tab-err error generation, conformal data cleaning (CDC), and mechanistic error detection (MechDetect) into one interactive demonstrator.
• Use of conformal prediction sets for uncertainty-calibrated detection and correction of erroneous cells in tabular data.
• Parametrizable error generation framework decoupling error type, mechanism, and rate based on Rubin's missing data taxonomy generalized to errors.
• Application of ML model performance comparisons to classify underlying error mechanisms in tabular data.

Datasets

• Nuclear power plant dataset — moderate size (~thousands of rows) — public via OpenML ID 44969

Baselines vs proposed

• CDC TPR under EAR: 0.6504 vs ECAR: 0.6488 vs ENAR: 0.6459
• CDC FPR under EAR: 0.0065 vs ECAR: 0.0066 vs ENAR: 0.0070
• CDC Downstream Improvement under EAR: 0.0349 vs ECAR: 0.0069 vs ENAR: 0.0285
• MechDetect accuracy numeric columns: ECAR 0.9421, EAR 0.9900, ENAR 0.7327
• MechDetect accuracy categorical columns: ECAR 0.9295, EAR 0.9984, ENAR 0.7079

Figures from the paper

Figures are reproduced from the source paper for academic discussion. Original copyright: the paper authors. See arXiv:2607.20140.

Fig 1: Overview of CURED. Users can upload data, perturb data

Fig 2: Error generation phase of the demo

Fig 3: The task type should be specified here by the user as

Fig 4 (page 3).

Limitations

• Demonstrator restricts datasets to fewer than 10 columns and 10,000 rows, limiting scalability to larger real-world tables.
• Cleaning and detection methods focus on ML-based imputation and conformal prediction, excluding other error correction paradigms.
• MechDetect shows reduced accuracy (around 70-73%) for Errors Not At Random (ENAR), indicating difficulty in detecting some complex error dependencies.
• No adversarial attack evaluation or robustness testing against intentional data poisoning is conducted.
• Evaluation is limited to synthetic error injection scenarios rather than real-world noisy datasets.
• Parameter tuning and hyperparameter selection details are sparse; sensitivity analyses are not extensively reported.

Open questions / follow-ons

• How to extend MechDetect or other methods to improve classification accuracy for Errors Not At Random (ENAR) scenarios?
• Can the error mechanism detection be integrated tightly into cleaning pipelines to adapt cleaning strategies dynamically?
• How do these ML-based cleaning techniques perform on large-scale industrial datasets with complex error patterns and more columns?
• What are the impacts of adversarial or targeted corruptions, and how can robustness to such attacks be improved?

Why it matters for bot defense

For bot-defense and CAPTCHA practitioners, CURED provides an instructive framework to better understand the nature and detection of data errors in tabular inputs often encountered in backend systems, user logs, or telemetry data. The ability to realistically inject and characterize errors helps in simulating noisy input scenarios that defensive ML models or decision systems might face. The conformal data cleaning approach offers a statistically principled way to flag and repair suspicious input values, potentially serving as a preprocessing step in bot-detection pipelines to reduce noise and false positives.

However, CURED's focus on tabular data error modeling and cleaning is somewhat orthogonal to the typical focus on adversarial bot inputs and CAPTCHAs. Its emphasis on naturalistic error mechanisms rather than adversarial evasion limits direct applicability in threat modeling active bot attackers. Still, techniques such as error mechanism detection via ML model comparison may inspire diagnostic tools for understanding failure modes and systematic biases in large-scale bot or abuse telemetry data, fostering more robust detection models.

Cite

@article{arxiv2607_20140,
  title={ CURED: Creating, Understanding, and Repairing Errors Demonstrator },
  author={ Nicholas Chandler and Sebastian Jäger and Philipp Jung and Felix Bießmann },
  journal={arXiv preprint arXiv:2607.20140},
  year={ 2026 },
  url={https://arxiv.org/abs/2607.20140}
}

Read the full paper

• arXiv:2607.20140 (abstract)
• arXiv:2607.20140 (PDF)