TabINR: An Implicit Neural Representation Framework for Tabular Data Imputation

## Abstract

Abstract Tabular data builds the basis for a wide range of applications, yet real-world datasets are frequently incomplete due to collection errors, privacy restrictions, or sensor failures. As missing values degrade the performance or hinder the applicability of downstream models, and while simple imputing strategies tend to introduce bias or distort the underlying data distribution, we require imputers that provide high-quality imputations, are robust across dataset sizes and yield fast inference. We therefore introduce TabINR , an auto-decoder based Implicit Neural Representation (INR) framework that models tables as neural functions. Building on recent advances in generalizable INRs, we introduce learnable row and feature embeddings that effectively deal with the discrete structure of tabular data and can be inferred from partial observations, enabling instance adaptive imputations without modifying the trained model. We evaluate our framework across a diverse range of twelve real-world datasets and multiple missingness mechanisms, demonstrating consistently strong imputation accuracy, mostly matching or outperforming classical (KNN, MICE, MissForest) and deep learning based models (GAIN, ReMasker), with the clearest gains on high-dimensional datasets.

## 1 Introduction

Tabular data remains one of the most common data formats across domains such as healthcare, finance, and the social sciences (Shwartz-Ziv & Armon, 2022).
In these fields, missing values are ubiquitous and can severely degrade the performance of downstream machine learning models.
Poor handling of missingness not only reduces predictive accuracy but may also lead to biased decisions, with real-world consequences for applications such as medical diagnostics or financial risk assessment.
These challenges make robust imputation a critical step for trustworthy tabular learning and data-driven decision making (Rubin, 1976).

Unlike images, time series or text, tabular data exhibits unique characteristics that make imputation particularly difficult.
First, it typically combines heterogeneous feature types such as continuous, categorical, and ordinal variables, which require different treatment. Moreover, many features exhibit complex nonlinear relationships and strong interdependencies, which must be taken into account (Shwartz-Ziv & Armon, 2022).
Second, tabular data usually lacks the spatial or sequential structure present in vision or language data. There is no inherent ordering of features across columns, and rows are often assumed to be independent. This removes many inductive biases that image or sequence models can exploit.
Third, many real-world tabular datasets are relatively small compared to their feature dimensionality, making it difficult for complex models to reliably generalize.

An additional complication arises from the different mechanisms through which missing values occur (Rubin, 1976). An overview of the three most common mechanisms is shown in [Figure 1](https://arxiv.org/html/2510.01136v1#S1.F1).
In the Missing Completely at Random (MCAR) setting, the probability of missingness is unrelated to either observed or unobserved data. While this assumption makes imputation relatively straightforward, it is also highly restrictive and rarely satisfied in practice.
In the more realistic Missing at Random (MAR) case, missingness depends on the observed variables but not on the missing ones themselves, requiring models to accurately capture conditional dependencies.
The most challenging scenario is Missing Not at Random (MNAR), where the likelihood of missingness depends directly on the unobserved values. In this situation, unbiased estimation is generally impossible without imposing strong assumptions, explicitly modeling the missingness process, or incorporating domain-specific knowledge.

Figure: Figure 1: Directed acyclic graphs illustrating common missing-data mechanisms for a partially observed variable $X$. White circles represent fully observed variables, gray circles represent unobserved or partially observed components, and squares denote the missingness indicators $R_{X}$. Arrows indicate causal or probabilistic dependence.
Refer to caption: x1.png

These factors make tabular imputation a central open problem for robust machine learning on structured data.

In this paper, we propose using Implicit Neural Representations (INRs) (Xie et al., 2022) for tabular data imputation. INRs represent data, in our case tables, as neural functions that map coordinates (e.g., row and column indices) to the corresponding values. We believe that such a neural data representation is a natural fit for imputation for several key reasons.
First, INRs can inherently fit data even when it is sparse or irregularly sampled. Once trained, the representation can be evaluated across the entire input domain, enabling the imputation of missing entries. Moreover, recent advances in generalizable INRs allow them to capture statistical regularities across datasets while still adapting to individual unseen rows through auto-decoder–style latent optimization (Park et al., 2019).
Unlike many conventional methods, INRs do not rely on strong distributional assumptions or arbitrary discretization choices. Instead, they learn a flexible representation capable of modeling complex dependencies directly from the data. Additionally, INRs are typically built using relatively simple Multilayer Perceptrons (MLPs), which results in a lightweight and fast solution.
Although INRs have been widely applied to images (Sitzmann et al., 2020), time series (Fons et al., 2022), and 3D scenes (Mildenhall et al., 2021), their application to tabular data, together with the unique challenges and opportunities this entails, remains largely unexplored.
Our mian contributions are:

- 1.
We propose TabINR, a unified INR framework for tabular data imputation that leverages learnable row and feature embeddings to represent instances and variables in a shared latent space.
- 2.
We introduce an auto-decoder-style test time latent optimization procedure that infers personalized embeddings for unseen instances from partial observations, enabling adaptability under sparse conditions.
- 3.
We conduct extensive benchmarks against classical and deep learning baselines, showing that INR-based models achieve competitive or superior performance across diverse imputation tasks while offering a conceptually simple and memory-efficient alternative to GAN and transformer-based approaches.

### 1.1 Related Work

##### Data Imputation Strategies

A variety of approaches have been proposed for imputing missing values in tabular datasets.
Early strategies rely on simple heuristics such as mean or mode substitution (Little & Rubin, 2019), expectation–maximization (Jerez et al., 2010), or matrix completion techniques (Hastie et al., 2015).
More sophisticated statistical methods include MICE (Van Buuren & Oudshoorn, 1999), MissForest (Stekhoven & Bühlmann, 2012), and MIRACLE (Kyono et al., 2021), which iteratively model conditional dependencies between features.
These methods are efficient and widely used, but they either ignore complex nonlinear patterns or depend on correct model specification, while poorly scaling to large datasets (White et al., 2011; Shah et al., 2014).

Deep generative models take a different perspective by modeling the joint distribution of all features.
GAN-based approaches such as GAIN (Yoon et al., 2018) and GAMIN (Yoon & Sull, 2020) treat imputation as a conditional generation problem, while VAE-based methods such as MIWAE (Mattei & Frellsen, 2019) and HI-VAE (Nazabal et al., 2020) apply probabilistic inference to heterogeneous tabular data.
Although expressive, these methods typically require large datasets and their adversarial or variational training objectives are often unstable and sensitive to hyperparameter choices.
More recently, masked modeling and transformer-based architectures such as TabTransformer (Huang et al., 2020), FT-Transformer (Gorishniy et al., 2021), SAINT (Somepalli et al., 2021), and ReMasker (Du et al., 2024) have demonstrated strong performance on imputation and downstream prediction.
However, these models are often heavily overparameterized, incurring substantial computational costs and limiting their scalability, especially on smaller or noisier datasets.

##### Implicit Neural Representations

Implicit Neural Representations (INRs) (Xie et al., 2022; Essakine et al., 2024) model data as continuous neural functions, that map from input coordinates, e.g., row and column indices, to the corresponding value. They have been applied to a large variety of different data modalities like sound (Sitzmann et al., 2020), images (Saragadam et al., 2023), shapes (Park et al., 2019), videos (Chen et al., 2022), or 3D scenes (Mildenhall et al., 2021), and have widely been adopted for a large variety of different tasks.
Recent research has primarily focused on addressing the spectral bias (Rahaman et al., 2019) inherent to MLPs typically used in INRs. Solutions include input embeddings such as Fourier Features (Tancik et al., 2020), specialized activation functions like SIREN (Sitzmann et al., 2020), Wire (Saragadam et al., 2023), Gauss (Ramasinghe & Lucey, 2022), HOSC (Serrano et al., 2024), and SINC (Saratchandran et al., 2024), as well as multi-resolution hash-grid encodings like InstantNGP (Müller et al., 2022). Other approaches explore training strategies to identify the most informative samples (Kheradmand et al., 2024; Tack et al., 2023) or techniques for optimal network initialization (Kania et al., 2024).
While most INR research focuses on single-instance representations without cohort priors, generalization across multiple instances (Park et al., 2019; Dupont et al., 2022; Bieder et al., 2024; Friedrich et al., 2025) has also been studied. For example, DeepSDF (Park et al., 2019) introduced the auto-decoder framework, which jointly optimizes network weights and signal-specific latent vectors. This framework allows the network to learn patterns shared across different instances, while new signals can be efficiently fitted by optimizing only a new latent vector with the network weights kept frozen.

## 2 Method

We propose a unified INR framework, shown in [Figure 2](https://arxiv.org/html/2510.01136v1#S2.F2), for modeling tabular data. Rather than treating missingness as a nuisance, we parameterize the table as a neural function conditioned on row and feature embeddings. For each cell $(i,j)$, the model maps a learnable row embedding and a learnable feature embedding to a scalar value, enabling a single network to support imputation, downstream prediction, and instance-specific inference.

Figure: Figure 2: The proposed TabINR framework. During training, we jointly optimize the network $f_{\theta}$, the row embeddings $\Lambda$, as well as feature embeddings $C$. Once the network is trained, new instances can be added by only optimizing a new row embedding $\lambda_{\text{new}}$, keeping $f_{\theta}$ and $C$ fixed.
Refer to caption: x2.png

### 2.1 TabINR

Let $\mathcal{D}\in\overline{\mathbb{R}}^{n\times m}$ denote a tabular dataset with $n$ rows (instances) and $m$ columns (features), where $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$ and $\emptyset$ denotes a missing entry. For each row $i$, the observed feature indices are denoted as

$$ $\Omega(\mathcal{D}_{i:})=\{j\mid\mathcal{D}_{ij}\neq\emptyset\}.$ (1) $$

Instead of treating the table as a static array, we model each cell value $\mathcal{D}_{ij}$ as the output of a neural function conditioned on a pair of embeddings:

$$ $\hat{\mathcal{D}}_{ij}=f_{\theta}(\lambda_{i},c_{j}),$ (2) $$

where:

- •
$\lambda_{i}\in\Lambda$ is the row embedding representing instance $i$,
- •
$c_{j}\in C$ is the feature embedding representing column $j$,
- •
$f_{\theta}$ is a shared neural network (e.g. an MLP) that maps the embedding pair $(\lambda_{i},c_{j})$ to a scalar output $\hat{\mathcal{D}}_{ij}$.

During training, only observed pairs $(i,j)\in\Omega(\mathcal{D}_{i:})$ contribute to the loss. For numerical features, mean squared error (MSE) is used, while for categorical features, expanded via one-hot encoding (OHE), binary cross-entropy (BCE) with logits is applied. This formulation allows the same architecture to handle both feature types within a unified objective.

To identify a suitable network architecture, we conducted a grid search over key hyperparameters. The final configuration, indicated in bold, was selected based on the lowest
average validation loss across all datasets.
Specifically, we varied the row and feature embedding dimensions
$\{16,\mathbf{32},64,128,256\}$, hidden layer widths
$\{64,128,\mathbf{256},512,1024\}$, number of hidden layers
$\{\mathbf{2},3,4,5,10,20\}$, dropout rates between $0.0$ and $\mathbf{0.1}$,
activation functions $\{\text{ReLU},\mathbf{\textbf{SIREN}},\text{WIRE},\text{SINC}\}$,
and learning rates $\{10^{-2},\mathbf{10^{-3}},10^{-4}\}$.
We emphasize that this choice reflects a
trade-off between stability and generalization across heterogeneous benchmarks, rather
than the absolute optimum on any single dataset. Later ablation studies
([Table 3](https://arxiv.org/html/2510.01136v1#S3.T3)) demonstrate that larger models can achieve marginally better results
on individual datasets.

### 2.2 Training Strategy

We define the set of observed entries as

$$ $\mathcal{O}=\{(i,j)\mid\mathcal{D}_{ij}\neq\emptyset\}.$ (3) $$

Training is performed only on this subset, ensuring that missing entries never directly contribute to the objective. For each observed pair $(i,j)$, the model predicts

$$ $\hat{\mathcal{D}}_{ij}=f_{\theta}(\lambda_{i},c_{j}),$ (4) $$

where $\lambda_{i}$ is the row embedding of instance $i$ and $c_{j}$ is the feature embedding of feature $j$.
To account for heterogeneous feature types, we use a mixed loss. Let $\mathcal{N}$ be the set of numerical features and let each original categorical feature $g$ be expanded into a one-hot group $\mathcal{B}_{g}=\{j_{1},\dots,j_{K_{g}}\}$ of binary columns. Denote by $\mathcal{B}=\bigcup_{g}\mathcal{B}_{g}$ the set of all binary one-hot columns. The loss is

$$ $\mathcal{L}(\theta,\Lambda,C)=\frac{1}{|\mathcal{O}|}\sum_{(i,j)\in\mathcal{O}}\begin{cases}\big(\hat{\mathcal{D}}_{ij}-\mathcal{D}_{ij}\big)^{2},&j\in\mathcal{N},\[6.0pt] -\Big[\mathcal{D}_{ij}\,\log\sigma(\hat{\mathcal{D}}_{ij})+(1-\mathcal{D}_{ij})\log\big(1-\sigma(\hat{\mathcal{D}}_{ij})\big)\Big],&j\in\mathcal{B},\end{cases}$ (5) $$

where $\sigma(\cdot)$ is the logistic sigmoid. Thus, for a categorical feature with $K_{g}$ categories, we compute one BCE term per one-hot component. Predicted logits are projected back to a valid category via $\arg\max$ within each one-hot group (winner-takes-all) during inference.
Optimization used Adam (Kingma, 2014) with cosine annealing learning rate scheduling and early stopping based on validation loss. During training, we applied random masking of $10$–$70\text{\,}\mathrm{\char 37\relax}$ of entries to simulate missingness and evaluate reconstruction fidelity.

### 2.3 Test Time Adaptation via Latent Optimization

At inference, we may encounter a new row $P\in\overline{\mathbb{R}}^{m}$ with only a subset of features observed, denoted by $\Omega(P)$. Since this row has no pretrained embedding, we introduce a fresh row embedding $\lambda_{\text{new}}$ (initialized randomly) and optimize it while keeping the network parameters $\theta$ and feature embeddings $\{c_{j}\}$ fixed:

$$ $\lambda_{\text{new}}=\operatorname*{arg\,min}_{\lambda}\sum_{j\in\Omega(P)\cap\mathcal{N}}\big(f_{\theta}(\lambda,c_{j})-P_{j}\big)^{2}\;+\;\sum_{j\in\Omega(P)\cap\mathcal{B}}\mathrm{BCEWithLogits}\ \!\big(f_{\theta}(\lambda,c_{j}),P_{j}\big).$ (6) $$

At inference, the row embedding is optimized to fit the observed features, and once this adaptation stabilizes, the missing entries can be imputed.

## 3 Experiments and Results

##### Datasets & Preprocessing

We benchmarked TabINR against commonly used imputers including mean/mode imputing, K-Nearest Neighbor (KNN), multiple imputation by chained equations (MICE)(Van Buuren & Oudshoorn, 1999), MissForest (Stekhoven & Bühlmann, 2012), ReMasker (Du et al., 2024), and GAIN (Yoon et al., 2018). We evaluate our method on twelve publicly available real-world benchmarks spanning different domains, with datasets drawn from the UCI Machine Learning Repository (Dua & Graff, 2017). These datasets vary widely in sample size, dimensionality, and feature composition, covering low- and high-dimensional features as well as mixed numerical and categorical variables. A detailed summary of dataset statistics, including size and number of features, is provided in the Appendix ([Table 4](https://arxiv.org/html/2510.01136v1#A1.T4)). This enables a systematic evaluation of TabINR across heterogeneous tabular data.

Preprocessing follows a consistent pipeline. Column types are inferred (or taken from dataset metadata) and numerical features are retained as real-valued, while categorical features are expanded via OHE. During training, numerical features are min–max scaled inside the loop (for both TabINR and GAIN), while OHE columns remain binary. At inference, categorical predictions are projected back to valid one-hot vectors using a winner-takes-all heuristic.

TabINR is implemented in PyTorch. Row and feature embeddings are initialized from a standard normal distribution and optimized jointly with the shared MLP, which uses SIREN activation functions. Optimization employs Adam with cosine annealing learning-rate scheduling and early stopping on a validation split. All experiments were conducted on an NVIDIA A100 GPU ($40\text{\,}\mathrm{GB}$). Competing baselines were configured in line with prior work (Yoon et al., 2018; Mattei & Frellsen, 2019; Hastie et al., 2015; Jarrett et al., 2022) to ensure comparability.

##### Missingness Synthetization

As the UCI benchmarks are fully observed, we synthetically introduce missing values at varying rates $p_{\text{miss}}$ under three standard mechanisms, shown in [Figure 1](https://arxiv.org/html/2510.01136v1#S1.F1). In the MCAR setting, entries are independently masked according to a Bernoulli distribution, yielding uniform missingness across the table. In the MAR setting, a subset of features is designated as always observed, while the others are masked using a logistic model conditioned on the observed subset. MNAR, extends MAR by additionally applying Bernoulli masking to values left unmasked, creating missingness that depends directly on the underlying data distribution.

To ensure consistency with established practice, we adapt the missingness mechanisms implementation from HyperImpute (Jarrett et al., 2022), which has been widely used in prior imputation studies (Yoon et al., 2018; Mattei & Frellsen, 2019; Hastie et al., 2015). The fully observed, OHE-expanded matrices serve as ground truth for evaluation, while the incomplete tables and masks define the observed entries available to the model during training and the held-out entries for evaluation.

Figure: Figure 3: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MCAR with $0.1$ missingness ratio. The results are shown as the mean and standard deviation of RMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x3.png

### 3.1 Benchmark: Imputation

We train TabINR on each dataset and evaluate its ability to reconstruct both numerical and categorical variables under controlled missingness. For numerical features, performance is quantified using normalized root mean squared error (NRMSE), where per-feature RMSE is normalized by the feature’s standard deviation and averaged across variables. For categorical features, evaluation is based on the area under the receiver operating characteristic curve (AUROC).

Across all three missingness mechanisms (MCAR, MAR, MNAR) and missingness rates ranging from $10\text{\,}\mathrm{\char 37\relax}$ to $70\text{\,}\mathrm{\char 37\relax}$, TabINR consistently ranks among the top-performing imputers and frequently achieves the best accuracy on high-dimensional datasets such as bike and spam. Under MCAR conditions, differences between methods remain modest, yet TabINR typically matches or exceeds the strongest classical baselines. Under MAR and especially MNAR, the performance spread widens: KNN and MICE degrade substantially due to their sensitivity to missingness patterns, while TabINR maintains stable reconstruction accuracy. Among competing methods, ReMasker is the most competitive deep baseline, while MissForest remains strong on smaller or predominantly categorical datasets. Nevertheless, TabINR generally delivers lower NRMSE for numerical features and comparable or higher AUROC for categorical features across the majority of benchmarks.

As expected, performance worsens for all methods as the missingness ratio increases, but TabINR degrades gracefully. Even at $70\text{\,}\mathrm{\char 37\relax}$ missingness, it remains within the top three methods across nearly all datasets, with only occasional wins by ReMasker or MissForest on structured, lower-dimensional tables. These findings align with our sensitivity analysis, where TabINR benefited most from larger sample sizes and higher feature counts, whereas iterative (MICE) and local (KNN) approaches rapidly lost ground as sparsity and dimensionality increased. Overall, the results demonstrate that TabINR achieves robust numerical imputations (low NRMSE) and strong categorical reconstruction (high AUROC), with the clearest advantages observed in non-MCAR and high-dimensional datasets. Results are summarized in [Figure 3](https://arxiv.org/html/2510.01136v1#S3.F3) and reported in detail in the Appendix ([Figure 6](https://arxiv.org/html/2510.01136v1#A1.F6)–[Figure 16](https://arxiv.org/html/2510.01136v1#A1.F16)).

Figure: Figure 4: Inference-time comparison across imputers (lower is better). Bars show mean seconds per dataset over $5$ runs; error bars denote $\pm$$1$$\,\mathrm{SD}$. While Mean/Mode is trivially fastest, TabINR and ReMasker achieve sub-$0.25\text{\,}\mathrm{s}$ inference once trained, whereas iterative baselines (KNN, MICE, MissForest) are markedly slower on higher-dimensional datasets. Results shown for MAR with $p_{\text{miss}}=0.3$; trends are consistent under MCAR/MNAR.
Refer to caption: x4.png

#### 3.1.1 Inference Time Efficiency

In addition to reconstruction quality, we benchmark test time efficiency across methods. Classical iterative approaches such as MICE, MissForest, and KNN exhibit the highest runtimes, frequently exceeding one second per dataset and scaling poorly with larger feature spaces (e.g., climate, credit). In contrast, simple heuristics such as mean/mode imputation are trivially fastest, as they involve no training or iterative optimization. Generative approaches such as ReMasker, as well as our proposed TabINR, achieve efficient inference once trained, requiring only $0.1$–$0.2$ seconds on most datasets. This efficiency stems from the embedding-based formulation: imputations are performed through lightweight forward passes, rather than repeated regressions or tree growth. Inference-time comparisons are shown in [Figure 4](https://arxiv.org/html/2510.01136v1#S3.F4). While results reported in the main text focus on MAR with $30\text{\,}\mathrm{\char 37\relax}$ missingness for clarity, the same trends hold under MCAR and MNAR.

#### 3.1.2 Permutation Robustness

A potential concern when applying implicit neural representations to tabular data is that row and column indices lack inherent ordering, raising the question of whether performance depends on dataset permutation. TabINR solves this issue by not relying on absolute positional encodings: each row and each feature is associated with a learnable embedding, and the model reconstructs entries by combining these embeddings. Consequently, permuting rows or columns simply permutes the associated embeddings without altering the learned mapping. To verify this empirically, we performed experiments in which both rows and columns were permuted before training, confirming that NRMSE and AUROC remained stable. [Table 1](https://arxiv.org/html/2510.01136v1#S3.T1) reports the results, demonstrating that TabINR is invariant to dataset permutations and does not exploit any hidden spatial structure. Hyperparameters for these experiments are provided in the Appendix [Table 5](https://arxiv.org/html/2510.01136v1#A1.T5).

**Table 1: Permutation robustness on letter (MCAR, $p_{\text{miss}}{=}0.3$). Each row permutes feature indices before training. Performance is stable across shuffles.**
| Sample | Permutation (indices 0–15) | NRMSE ($\downarrow$) | AUROC ($\uparrow$) |
| --- | --- | --- | --- |
| baseline | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 | $0.128$ | $0.851$ |
| $1$ | 7,3,12,1,9,6,14,0,5,10,2,8,15,4,11,13 | $0.128$ | $0.852$ |
| $2$ | 5,14,2,8,11,0,10,3,12,7,1,9,6,13,15,4 | $0.129$ | $0.850$ |
| $3$ | 9,0,7,12,3,10,15,6,1,14,8,5,2,11,4,13 | $0.127$ | $0.853$ |
| $4$ | 11,6,1,15,8,3,4,12,14,2,9,0,13,10,5,7 | $0.128$ | $0.849$ |
| $5$ | 2,9,5,13,0,8,10,1,7,4,12,15,3,14,6,11 | $0.128$ | $0.852$ |
| $6$ | 4,8,14,6,12,11,9,2,3,7,13,1,10,5,15,0 | $0.129$ | $0.850$ |
| $7$ | 10,5,0,7,1,12,3,9,6,13,15,2,8,11,4,14 | $0.128$ | $0.851$ |
| $8$ | 13,2,11,4,7,1,8,15,10,0,6,14,5,3,12,9 | $0.127$ | $0.852$ |

### 3.2 Downstream Classification

We conducted a downstream classification task to evaluate the practical utility of imputations in predictive pipelines. We simulated missingness for each dataset with categorical targets, performed full-column imputation of the target variable using different imputation methods, and then trained XGBoost classifiers (Chen & Guestrin, 2016) on the completed datasets. This setup reflects a realistic use case in which imputation quality directly impacts the performance of a subsequent model. The preparation process mirrors the imputation benchmark. The fully imputed datasets then served as input to XGBoost, with AUROC as the evaluation metric. Results were averaged across four missingness ratios ($10\text{\,}\mathrm{\char 37\relax}$, $30\text{\,}\mathrm{\char 37\relax}$, $50\text{\,}\mathrm{\char 37\relax}$, and $70\text{\,}\mathrm{\char 37\relax}$) to ensure robustness. [Table 2](https://arxiv.org/html/2510.01136v1#S3.T2) reports AUROC scores on five UCI datasets with categorical targets. TabINR combined with XGBoost achieved the best performance on obesity and spam, while ReMasker performed slightly stronger on letter. On raisin and credit, KNN-based imputation provided competitive results. We additionally evaluated the performance of TabINR as a classifier, by treating the target label as the variable to be imputed.

**Table 2: Downstream classification (full-column imputation of the target) measured by AUROC (mean $\pm$ std). Best result per dataset is bold.**
| Pipeline |  | credit | letter | obesity | raisin | spam |
| --- | --- | --- | --- | --- | --- | --- |
| Original Data (fully observed) | +XGBoost | $.835\pm.008$ | $.930\pm.006$ | $.940\pm.006$ | $.840\pm.008$ | $.915\pm.006$ |
| TabINR Imputation | +XGBoost | $.848\pm.007$ | $.927\pm.006$ | $\mathbf{.947\pm.005}$ | $.852\pm.007$ | $\mathbf{.922\pm.005}$ |
| KNN Imputation | +XGBoost | $\mathbf{.852\pm.007}$ | $.922\pm.007$ | $.942\pm.006$ | $\mathbf{.855\pm.007}$ | $.918\pm.006$ |
| MissForest Imputation | +XGBoost | $.850\pm.007$ | $.925\pm.006$ | $.945\pm.005$ | $.853\pm.007$ | $.920\pm.005$ |
| MICE Imputation | +XGBoost | $.847\pm.007$ | $.921\pm.007$ | $.943\pm.006$ | $.852\pm.007$ | $.917\pm.006$ |
| GAIN Imputation | +XGBoost | $.845\pm.007$ | $.919\pm.007$ | $.941\pm.006$ | $.851\pm.007$ | $.916\pm.006$ |
| ReMasker Imputation | +XGBoost | $.851\pm.007$ | $\mathbf{.932\pm.006}$ | $.946\pm.005$ | $.854\pm.007$ | $.921\pm.005$ |
| Direct TabINR classifier |  | $.820\pm.009$ | $.910\pm.008$ | $.930\pm.007$ | $.830\pm.008$ | $.905\pm.007$ |

Overall, these findings confirm that imputations produced by TabINR translate into strong downstream predictive performance. While no single method dominates across all datasets, TabINR consistently provides competitive or superior results, demonstrating that INR-based imputations are not only accurate in reconstruction but also effective for downstream classification tasks.

### 3.3 Ablation Study

To better understand the robustness of all comparing methods, we conduct multiple ablation studies by varying the dataset size, feature dimensionality, and missingness ratio. Several consistent trends emerged: (a) performance of all methods improved with larger datasets, but TabINR and ReMasker gained a more pronounced advantage with larger data sizes; (b) as the number of features increased, TabINR maintained stable performance, while baseline methods such as KNN and MICE degraded; and (c) under higher missingness ratios (greater than $0.5$), performance differences between models narrowed, with TabINR and ReMasker remaining the most resilient. These results highlight the scalability of INR-based approaches and their particular strength on challenging, high-dimensional settings. This can be observed in [Figure 5](https://arxiv.org/html/2510.01136v1#S3.F5).
Additional ablation experiments across the other missingness mechanisms can be found in the Appendix ([Figure 17](https://arxiv.org/html/2510.01136v1#A1.F17)–[Figure 27](https://arxiv.org/html/2510.01136v1#A1.F27)).

Figure: Figure 5: Sensitivity analysis of TabINR on the letter dataset under MCAR scenarios. The results are shown in terms of RMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.1$.
Refer to caption: x5.png

[Table 3](https://arxiv.org/html/2510.01136v1#S3.T3) reports the ablation over depth, latent dimension, width, and activation on letter (MCAR, $p_{\text{miss}}{=}0.1$). Performance improves with capacity and then plateaus: best NRMSE occurs around $10$ layers with $512$–$1024$ units and a $256$-d latent ($\approx$ $0.125$); SIREN achieves the highest AUROC ($0.864$), and HOSC the lowest NRMSE ($0.125$). This trend is dataset-specific, and in our main results we adopt the global defaults from Section 2.1 (Table [5](https://arxiv.org/html/2510.01136v1#A1.T5)) to ensure robustness and comparability across benchmarks, rather than per-dataset peak tuning.

**Table 3: Ablation study of TabINR on the letter dataset (MCAR, $p_{\text{miss}}=0.1$). For comparability, we define a separate default configuration here (depth = $4$, latent dimension = $64$, hidden units = $256$, activation = SIREN), which differs from the global defaults in [Table 5](https://arxiv.org/html/2510.01136v1#A1.T5). This setup serves only as a controlled baseline for sensitivity analysis. Results show that performance improves with additional capacity (depth, width, latent size), although gains plateau beyond a certain point and do not consistently generalize across all datasets.**
| Layers | NRMSE ($\downarrow$) | AUROC ($\uparrow$) |
| --- | --- | --- |
| $2$ | $0.134$ | $0.843$ |
| $3$ | $0.130$ | $0.846$ |
| $4$ | $0.128$ | $0.850$ |
| $5$ | $0.126$ | $0.852$ |
| $10$ | $0.125$ | $0.854$ |
| $20$ | $0.127$ | $0.853$ |

## 4 Conclusion

Our study demonstrates that Implicit Neural Representations (INRs) offer a simple yet flexible framework for imputing missing values in tabular data. By parameterizing entries with learnable row and feature embeddings and enabling instance-level adaptation through test time optimization, TabINR bridges the gap between classical imputers and recent deep learning based approaches.

While our results are promising, several limitations remain. First, our experiments focused on moderate-scale benchmarks with synthetically induced missingness. Applying TabINR under real-world settings with more complex missingness patterns and the need for integrating domain knowledge, remains unexplored. Second, we employed a single global default configuration across datasets to ensure comparability. This favors stability but likely underestimates the model’s best-case performance. Finally, although we compared against strong classical and generative baselines, we did not exhaustively benchmark against the latest transformer-based classifiers trained end-to-end.

For future work, we aim to extend TabINR to handle non-random missingness, scale to larger datasets, and incorporate automated hyperparameter adaptation. We also plan to integrate TabINR into multimodal pipelines for jointly modeling tabular data with images or text.

More broadly, our work suggests that INRs can serve as a unifying lens for tabular learning. By framing missing value imputation as a continuous representation learning problem, TabINR opens new directions for bringing the benefits of implicit representations to core challenges in tabular data analysis.

## 5 ACKNOWLEDGMENTS

This work was funded by the grant A1813455-SY from Medtronic and by the Vontobel foundation with the number: 0132/2024. Any opinions, findings, and conclusions
or recommendations expressed in this material are those of the author(s) and do not necessarily reflect
the views of the funder.

## References

- Bieder et al. (2024)
Florentin Bieder, Paul Friedrich, Hélène Corbaz, Alicia Durrer, Julia Wolleb, and Philippe C. Cattin.
Modeling the neonatal brain development using implicit neural representations.
In *International Workshop on PRedictive Intelligence In MEdicine*, pp. 1–11. Springer, 2024.
- Chen & Guestrin (2016)
Tianqi Chen and Carlos Guestrin.
Xgboost: A scalable tree boosting system.
In *Proceedings of the 22nd acm sigkdd international conference on knowledge discovery and data mining*, pp. 785–794, 2016.
- Chen et al. (2022)
Zeyuan Chen, Yinbo Chen, Jingwen Liu, Xingqian Xu, Vidit Goel, Zhangyang Wang, Humphrey Shi, and Xiaolong Wang.
Videoinr: Learning video implicit neural representation for continuous space-time super-resolution.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 2047–2057, 2022.
- Du et al. (2024)
Tianyu Du, Luca Melis, and Ting Wang.
Remasker: Imputing tabular data by re-masking and reconstruction.
In *International Conference on Learning Representations (ICLR)*, 2024.
- Dua & Graff (2017)
Dheeru Dua and Casey Graff.
Uci machine learning repository.
[http://archive.ics.uci.edu/ml](http://archive.ics.uci.edu/ml), 2017.
- Dupont et al. (2022)
Emilien Dupont, Hyunjik Kim, SM Ali Eslami, Danilo Jimenez Rezende, and Dan Rosenbaum.
From data to functa: Your data point is a function and you can treat it like one.
In *International Conference on Machine Learning*, pp. 5694–5725. PMLR, 2022.
- Essakine et al. (2024)
Amer Essakine, Yanqi Cheng, Chun-Wun Cheng, Lipei Zhang, Zhongying Deng, Lei Zhu, Carola-Bibiane Schönlieb, and Angelica I Aviles-Rivero.
Where do we stand with implicit neural representations? a technical and performance survey.
*arXiv preprint arXiv:2411.03688*, 2024.
- Fons et al. (2022)
Elizabeth Fons, Alejandro Sztrajman, Yousef El-Laham, Alexandros Iosifidis, and Svitlana Vyetrenko.
Hypertime: Implicit neural representations for time series.
In *NeurIPS 2022 Workshop on Synthetic Data for Empowering ML Research*, 2022.
- Friedrich et al. (2025)
Paul Friedrich, Florentin Bieder, and Philippe C Cattin.
Medfuncta: Modality-agnostic representations based on efficient neural fields.
*arXiv preprint arXiv:2502.14401*, 2025.
- Gorishniy et al. (2021)
Yury Gorishniy, Ivan Rubachev, Valentin Khrulkov, and Artem Babenko.
Revisiting deep learning models for tabular data.
In *Advances in Neural Information Processing Systems (NeurIPS)*, 2021.
- Hastie et al. (2015)
Trevor Hastie, Rahul Mazumder, Jason D Lee, and Reza Zadeh.
Matrix completion and low-rank svd via fast alternating least squares.
*Journal of Machine Learning Research*, 16(104):3367–3402, 2015.
- Huang et al. (2020)
Xin Huang, Ashish Khetan, Milan Cvitkovic, and Zohar Karnin.
Tabtransformer: Tabular data modeling using contextual embeddings.
*arXiv preprint arXiv:2012.06678*, 2020.
- Jarrett et al. (2022)
Daniel Jarrett, Bogdan C Cebere, Tennison Liu, Alicia Curth, and Mihaela van der Schaar.
Hyperimpute: Generalized iterative imputation with automatic model selection.
In *International Conference on Machine Learning*, pp. 9916–9937. PMLR, 2022.
- Jerez et al. (2010)
José M Jerez, Irene Molina, Pedro J García-Laencina, Emilio Alba, Nicolás Ribelles, M Martín, and Leonardo Franco.
Missing data imputation using statistical and machine learning methods in a real breast cancer problem.
*Artificial Intelligence in Medicine*, 50(2):105–115, 2010.
- Kania et al. (2024)
Adam Kania, Marko Mihajlovic, Sergey Prokudin, Jacek Tabor, PrzemysĹ Spurek, et al.
Fresh: Frequency shifting for accelerated neural representation learning.
*arXiv preprint arXiv:2410.05050*, 2024.
- Kheradmand et al. (2024)
Shakiba Kheradmand, Daniel Rebain, Gopal Sharma, Hossam Isack, Abhishek Kar, Andrea Tagliasacchi, and Kwang Moo Yi.
Accelerating neural field training via soft mining.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 20071–20080, 2024.
- Kingma (2014)
Diederik P Kingma.
Adam: A method for stochastic optimization.
*arXiv preprint arXiv:1412.6980*, 2014.
- Kyono et al. (2021)
Trent Kyono, Yao Zhang, Alexis Bellot, and Mihaela van der Schaar.
Miracle: Causally-aware imputation via learning missing data mechanisms.
In *International Conference on Learning Representations (ICLR)*, 2021.
- Little & Rubin (2019)
Roderick JA Little and Donald B Rubin.
*Statistical analysis with missing data*.
John Wiley & Sons, 2019.
- Mattei & Frellsen (2019)
Pierre-Alexandre Mattei and Jes Frellsen.
Miwae: Deep generative modelling and imputation of incomplete data sets.
In *International Conference on Machine Learning (ICML)*, pp. 4413–4423, 2019.
- Mildenhall et al. (2021)
Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng.
Nerf: Representing scenes as neural radiance fields for view synthesis.
*Communications of the ACM*, 65(1):99–106, 2021.
- Müller et al. (2022)
Thomas Müller, Alex Evans, Christoph Schied, and Alexander Keller.
Instant neural graphics primitives with a multiresolution hash encoding.
*ACM transactions on graphics (TOG)*, 41(4):1–15, 2022.
- Nazabal et al. (2020)
Alfredo Nazabal, Pablo M Olmos, Zoubin Ghahramani, and Isabel Valera.
Handling incomplete heterogeneous data using vaes.
*Pattern Recognition*, 107:107501, 2020.
- Park et al. (2019)
Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove.
Deepsdf: Learning continuous signed distance functions for shape representation.
In *Proceedings of the IEEE/CVF conference on computer vision and pattern recognition*, pp. 165–174, 2019.
- Rahaman et al. (2019)
Nasim Rahaman, Aristide Baratin, Devansh Arpit, Felix Draxler, Min Lin, Fred Hamprecht, Yoshua Bengio, and Aaron Courville.
On the spectral bias of neural networks.
In *International conference on machine learning*, pp. 5301–5310. PMLR, 2019.
- Ramasinghe & Lucey (2022)
Sameera Ramasinghe and Simon Lucey.
Beyond periodicity: Towards a unifying framework for activations in coordinate-mlps.
In *European Conference on Computer Vision (ECCV)*, pp. 142–158, 2022.
- Rubin (1976)
Donald B Rubin.
Inference and missing data.
*Biometrika*, 63(3):581–592, 1976.
- Saragadam et al. (2023)
Vishwanath Saragadam, Daniel LeJeune, Jasper Tan, Guha Balakrishnan, Ashok Veeraraghavan, and Richard G Baraniuk.
Wire: Wavelet implicit neural representations.
In *Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition*, pp. 18507–18516, 2023.
- Saratchandran et al. (2024)
Hemanth Saratchandran, Sameera Ramasinghe, Violetta Shevchenko, Alexander Long, and Simon Lucey.
A sampling theory perspective on activations for implicit neural representations.
In *Proceedings of the 41st International Conference on Machine Learning*, pp. 43422–43444, 2024.
- Serrano et al. (2024)
Danzel Serrano, Jakub Szymkowiak, and Przemyslaw Musialski.
Hosc: A periodic activation function for preserving sharp features in implicit neural representations.
*arXiv preprint arXiv:2401.10967*, 2024.
- Shah et al. (2014)
Anoop D Shah, Jonathan W Bartlett, James Carpenter, Owen Nicholas, and Harry Hemingway.
Comparison of random forest and parametric imputation models for imputing missing data using mice: a caliber study.
*American journal of epidemiology*, 179(6):764–774, 2014.
- Shwartz-Ziv & Armon (2022)
Ravid Shwartz-Ziv and Amitai Armon.
Tabular data: Deep learning is not all you need.
*Information Fusion*, 81:84–90, 2022.
- Sitzmann et al. (2020)
Vincent Sitzmann, Julien N. P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein.
Implicit neural representations with periodic activation functions.
In *Advances in Neural Information Processing Systems (NeurIPS)*, 2020.
- Somepalli et al. (2021)
Gowthami Somepalli, Micah Goldblum, Avi Schwarzschild, C Bayan Bruss, and Tom Goldstein.
Saint: Improved neural networks for tabular data via row attention and contrastive pre-training.
*arXiv preprint arXiv:2106.01342*, 2021.
- Stekhoven & Bühlmann (2012)
Daniel J Stekhoven and Peter Bühlmann.
Missforest—non-parametric missing value imputation for mixed-type data.
*Bioinformatics*, 28(1):112–118, 2012.
- Tack et al. (2023)
Jihoon Tack, Subin Kim, Sihyun Yu, Jaeho Lee, Jinwoo Shin, and Jonathan Richard Schwarz.
Learning large-scale neural fields via context pruned meta-learning.
*Advances in Neural Information Processing Systems*, 36:72624–72647, 2023.
- Tancik et al. (2020)
Matthew Tancik, Pratul Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan Barron, and Ren Ng.
Fourier features let networks learn high frequency functions in low dimensional domains.
*Advances in neural information processing systems*, 33:7537–7547, 2020.
- Van Buuren & Oudshoorn (1999)
Stef Van Buuren and Karin Oudshoorn.
*Flexible multivariate imputation by MICE*, volume 21.
Leiden: TNO, 1999.
- White et al. (2011)
Ian R White, Patrick Royston, and Angela M Wood.
Multiple imputation using chained equations: Issues and guidance for practice.
*Statistics in Medicine*, 30(4):377–399, 2011.
doi: 10.1002/sim.4067.
- Xie et al. (2022)
Yiheng Xie, Towaki Takikawa, Shunsuke Saito, Or Litany, Shiqin Yan, Numair Khan, Federico Tombari, James Tompkin, Vincent Sitzmann, and Srinath Sridhar.
Neural fields in visual computing and beyond.
In *Computer graphics forum*, volume 41, pp. 641–676. Wiley Online Library, 2022.
- Yoon et al. (2018)
Jinsung Yoon, James Jordon, and Mihaela van der Schaar.
Gain: Missing data imputation using generative adversarial nets.
In *International Conference on Machine Learning (ICML)*, 2018.
- Yoon & Sull (2020)
Seongwook Yoon and Sanghoon Sull.
Gamin: Generative adversarial multiple imputation network for highly missing data.
In *Proceedings of the IEEE/CVF conference on computer vision and pattern recognition*, pp. 8456–8464, 2020.

## Appendix A Appendix

**Table 4: Characteristics of the datasets used in our experiments.**
| Dataset | Dataset Size | # Features | Task |
| --- | --- | --- | --- |
| (California) Housing | $20\,640$ | $9$ | Regression |
| (Climate) Model Simulation Crashes | $540$ | $18$ | Classification |
| Concrete (Compressive) Strength | $1030$ | $9$ | Regression |
| (Diabetes) | $442$ | $10$ | Regression |
| Estimation of (Obesity) Levels | $2111$ | $17$ | Classification |
| (Credit) Approval | $690$ | $15$ | Classification |
| (Wine) Quality | $1599$ | $12$ | Classification |
| (Raisin) | $900$ | $8$ | Classification |
| (Spam) Base | $4601$ | $57$ | Classification |
| (Bike) Sharing Demand | $8760$ | $14$ | Classification |
| (Letter) Recognition | $20\,000$ | $16$ | Classification |
| (Yacht) Hydrodynamics | $308$ | $7$ | Regression |

**Table 5: Baseline default parameter settings of TabINR.**
| Parameter | Setting |
| --- | --- |
| Latent dimension | $32$ |
| Number of hidden layers | $2$ |
| Number of units per hidden layer | $256$ |
| Dropout rate | $0.1$ |
| Activation function | SIREN |
| $\omega_{0}$ (for SIREN, Wire activations) | $30$ |
| Learning rate | $1\text{\times}{10}^{-3}$ |
| Training epochs | $500$ |
| Optimizer | Adam |
| Batch size | $64$ |
| Masking ratio | $0.3$ |

Figure: Figure 6: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MCAR with $0.3$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x6.png

Figure: Figure 7: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MCAR with $0.5$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x7.png

Figure: Figure 8: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MCAR with $0.7$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x8.png

Figure: Figure 9: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MAR with $0.1$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x9.png

Figure: Figure 10: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MAR with $0.3$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x10.png

Figure: Figure 11: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MAR with $0.5$ missingness ratio. The results are shown as the mean and standard deviation of RMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x11.png

Figure: Figure 12: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MAR with $0.7$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x12.png

Figure: Figure 13: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MNAR with $0.1$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x13.png

Figure: Figure 14: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MNAR with $0.3$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x14.png

Figure: Figure 15: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MNAR with $0.5$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x15.png

Figure: Figure 16: Overall performance of TabINR and six baselines on $12$ benchmark datasets under MNAR with $0.7$ missingness ratio. The results are shown as the mean and standard deviation of NRMSE, and AUROC scores (AUROC is only applicable to datasets with classification tasks).
Refer to caption: x16.png

Figure: Figure 17: Sensitivity analysis of TabINR on the letter dataset under MCAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.3$.
Refer to caption: x17.png

Figure: Figure 18: Sensitivity analysis of TabINR on the letter dataset under MCAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.5$.
Refer to caption: x18.png

Figure: Figure 19: Sensitivity analysis of TabINR on the letter dataset under MCAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.7$.
Refer to caption: x19.png

Figure: Figure 20: Sensitivity analysis of TabINR on the letter dataset under MAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.1$.
Refer to caption: x20.png

Figure: Figure 21: Sensitivity analysis of TabINR on the letter dataset under MAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.3$.
Refer to caption: x21.png

Figure: Figure 22: Sensitivity analysis of TabINR on the letter dataset under MAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.5$.
Refer to caption: x22.png

Figure: Figure 23: Sensitivity analysis of TabINR on the letter dataset under MAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.7$.
Refer to caption: x23.png

Figure: Figure 24: Sensitivity analysis of TabINR on the letter dataset under MNAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.1$.
Refer to caption: x24.png

Figure: Figure 25: Sensitivity analysis of TabINR on the letter dataset under MNAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.3$.
Refer to caption: x25.png

Figure: Figure 26: Sensitivity analysis of TabINR on the letter dataset under MNAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.5$.
Refer to caption: x26.png

Figure: Figure 27: : Sensitivity analysis of TabINR on the letter dataset under MNAR scenarios. The results are shown in terms of NRMSE and AUROC, with the scores measured with respect to (a) the dataset size, (b) the number of features, and (c) the missingness ratio. The default setting is as follows: dataset size = $20\,000$, number of features = $16$, and missingness ratio = $0.7$.
Refer to caption: x27.png

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 2
presentation: 2
questions: We would appreciate the authors' responses to the concerns raised in the weaknesses section above.
soundness: 2
strengths: * The paper tackles a fundamental issue of handling missing data, which is very common in practical data analysis and machine learning problems, where some data are missing due to reasons like sensor malfunction, communication problems, or privacy concerns.

* The proposed method is targeted to work well not only in a relatively simple MCAR case, but also in the case of MAR and MNAR missing mechanisms.

* The proposed approach takes a different approach for missing value imputation.
summary: The authors propose an Implicit Neural Representation (INR) based imputation method for tabular data. It represents the dataset as a function (in fact, a neural network) that maps a cell (represented by row embedding and column embedding) in the table to its corresponding numerical value. This function is trained on the non-missing cells and then used to fill in missing values as needed. The authors provide an evaluation against different baselines (both classical and neural network-based). The reported performance is on par with, if not superior to considered baselines.
weaknesses: * The paper lacks justification and a clear motivation for why the proposed method works. Section 2, the authors explained the proposed method step-by-step, but did not discuss why. It is more like a technical report than a research paper.

*  The presentation is not entirely clear to readers, particularly how missing values are imputed at inference (Sec 2.3).

* While the proposed method is competitive with the state-of-the-art methods in 12 datasets used, it is not particularly good in any case. The authors fail to provide any conclusion on what sort of scenario/case the proposed approach may be better than the SOTA methods.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. How does test-time optimization cost compare to baseline inference in wall-clock time?

2. The SIREN activation function introduces high-frequency components, is this actually beneficial for tabular data, which typically lacks such structure?
soundness: 3
strengths: 1. Applying INRs to tabular imputation is relatively unexplored (as far as I know) and conceptually interesting.

2. TabINR demonstrates faster inference than iterative methods, per dataset once trained, which is quite impressive and is practically useful.

3. The auto-decoder approach for inferring embeddings from partial observations is neat and enables instance-specific imputation.

4. The ablation analysis are well done and comprehensive.
summary: This paper proposes TabINR, which applies Implicit Neural Representations (INRs) to tabular data imputation. The approach models table entries as outputs of a neural function conditioned on learnable row and feature embeddings. At test time, new instances are handled via auto-decoder-style optimization of row embeddings while keeping the network frozen.
weaknesses: 1. TabINR shows competitive performance but gains over baselines are modest and inconsistent. ReMasker frequently matches or outperforms it imputation and downstream classification. While exploring a novel approach justifies some performance variability, the more critical concern arises from the fact that the benchmark omits recent state-of-the-art methods [1,2], making it unclear whether this represents meaingful progress in tabular imputation. Additionally, there appears to be a hyperparameter tuning imbalance. TabINR underwent grid search across datasets, while baselines used default settings configurations. This could be potentially inflating TabINR's relative performance. 

2. The results in Sec 3.1.2 are a good starting point to demonstrate permutation robustness. However, they demonstrates permutation invariance only under MCAR, where missingness is completely random and uninformative. Under this setting its almost certainly expected that the all models are permutation invariant. The meaningful test would be under MNAR, where missingness patterns carry information about the data structure. Without MNAR results, the claim of permutation robustness remains unconvincing.

#### References
[1] DiffPuter: Empowering Diffusion Models for Missing Data Imputation (ICLR 2025)

[2] CACTI: Leveraging Copy Masking and Contextual Information to Improve Tabular Data Imputation (ICML 2025)

---

confidence: 4
contribution: 2
initial_rating: 2
presentation: 3
questions: NAN
soundness: 2
strengths: S1: A new Implicit Neural Representation framework for missing data imputation.
S2: Comprehensive experiments are conducted.
summary: This paper studies the problem of missing values in tabular data. The authors propose TAB-INR, an auto-decoder–based Implicit Neural Representation (INR) framework that employs learnable row and feature embeddings for adaptive imputation from partial observations. Experiments on twelve real-world datasets show that TAB-INR achieves consistently superior imputation accuracy.
weaknesses: W1: The paper’s presentation needs improvement. In particular, the Introduction lacks sufficient discussion of related works on both data imputation and Implicit Neural Representations (INRs). As a result, the motivation for applying INR to imputation is unclear—specifically, what unique advantages INR offers for this problem and how the challenges in imputation naturally align with the strengths of INR.

W2: The paper misses comparisons with several state-of-the-art imputation methods, especially recent graph-based approaches such as
[1] Handling Missing Data with Graph Representation Learning and
[2] On LLM-Enhanced Mixed-Type Data Imputation with High-Order Message Passing.
These methods generally outperform older baselines like ReMasker and GAIN, and they also employ learnable representations for rows and columns. It remains unclear why the authors chose INR-based learnable features over graph-based ones or how their design offers any advantages.

W3: The experimental evaluation primarily compares against outdated baselines (e.g., GAIN, MissForest, MICE) while omitting more recent generative or graph-based models. Even within these limited comparisons, the improvements are not significant, which weakens the empirical contribution.

W4: The core contribution of the paper appears to be the straightforward application of the INR framework to the imputation task. Beyond this adaptation, the paper’s novel technical contribution is not clearly articulated, making it difficult to distinguish the originality or necessity of the proposed method.

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: 1. How are the training, validation, and test sets constructed? Do test samples appear during training such that they have pre-learned row embeddings, or are row embeddings only learned for training samples?

2. Could you clarify the masking procedure used during training and testing? In Line 215, it is mentioned that "During training, we applied random masking of 10–70 % of entries to simulate missingness and evaluate reconstruction fidelity." However, in Table 5, the masking ratio is set to 0.3.
soundness: 2
strengths: 1. The paper is clearly written and easy to follow.

2. The proposed method is lightweight and memory-efficient.
summary: This paper introduces TabINR, a missing value imputation method for tabular data. The key idea is to leverage Implicit Neural Representations (INRs) for imputation. For each cell, TabINR learns a row embedding and a feature embedding, and then uses an MLP to map their combination to a scalar value as the imputed result. To address the absence problem of row embeddings for unseen test samples, a test-time adaptation strategy is introduced to retrieve the most suitable row embedding from the training set. Experiments on 12 datasets across MCAR, MAR, and MNAR settings and different missing ratios are done to validate the effectiveness of the proposed method.
weaknesses: 1. The technical novelty of the proposed method is limited. The key idea is to learn row and feature embeddings for each row and column in the tabular data, which is common.

2. The proposed method does not seem to be effective, as it has higher NRMSE and lower AUROC compared with ReMasker in many cases in Figure 3. Similar trends are observed in Figure 7 - 16 under different settings.

3. The proposed test-time adaptation mechanism could be computationally expensive for large-scale datasets, since it requires searching over all row embeddings to find the one that minimizes the imputation error of all observed features in a test instance.

4. It is mentioned in the introduction that in tabular datasets, "rows are often assumed to be independents." This may not be true as many methods leverage the correlation between rows for imputation. In addition, the MCAR, MAR, and MNAR are three common settings. It may not be necessary to elaborate here.


Decision: Reject