TabINR: INR Framework for Tabular Imputation

• TabINR is an implicit neural representation framework that models tabular data as a neural function using learnable row and feature embeddings.
• It trains on observed entries with a self-supervised loss and performs instance-adaptive imputation by optimizing latent codes for unseen rows.
• Empirical results show TabINR matching or exceeding classical and deep methods, especially in high-dimensional datasets with 10–70% missing values.

TabINR is an auto-decoder based Implicit Neural Representation (INR) framework for tabular data imputation that treats a tabular dataset as a neural function rather than as a matrix of independently handled entries (Ochs et al., 1 Oct 2025). It is designed for settings in which rows are instances, columns are features, and missing values arise from collection errors, privacy restrictions, or sensor failures. The framework introduces learnable row and feature embeddings for the discrete structure of tabular data, trains only on observed entries, and performs instance-adaptive imputation for unseen rows without modifying the trained backbone. Across twelve real-world datasets and multiple missingness mechanisms, it is reported to mostly match or outperform classical methods such as KNN, MICE, and MissForest, as well as deep models such as GAIN and ReMasker, with the clearest gains on high-dimensional datasets (Ochs et al., 1 Oct 2025).

1. Problem setting and design objectives

Tabular datasets frequently contain missing values due to measurement errors, privacy filtering, device failures, and related causes. Missingness reduces effective sample size when incomplete rows are discarded and can introduce bias or distort the underlying data distribution when missing entries are filled crudely. In this setting, imputation is treated as a preprocessing step for reliable downstream prediction and decision-making, including in domains such as healthcare and finance.

The framework is motivated by limitations of several standard imputation families. Mean or mode imputation is very fast but ignores dependencies between features. KNN imputation uses nearest neighbors in feature space but struggles in high dimensions, can be slow at inference, and is sensitive to missingness patterns and scaling. MICE and MissForest iteratively regress features on one another or use random forests, but scale poorly with many features or large $n$ due to repeated model fitting and can become unstable and slow as missingness rate or dimensionality increases. Deep generative models such as GAIN often require large datasets, have unstable or sensitive training, and tend to be heavy in parameters and compute. Transformer-style masked modeling approaches such as ReMasker are strong recent baselines but are typically large models with heavy training cost and can be overparameterized for small or noisy tabular data.

Within that landscape, TabINR targets three properties: high-quality imputations across diverse missingness mechanisms, robustness across dataset sizes, and fast inference once training is complete. A plausible implication is that the method is positioned between lightweight classical imputers and large deep architectures: it retains a compact MLP-based core while still modeling global nonlinear dependencies.

2. Functional representation of a table

TabINR models a dataset $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$, where $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$ and $\emptyset$ denotes a missing entry. For row $i$, the observed feature indices are

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

Its central functional form is

$\hat{\mathcal{D}}_{ij}=f_\theta(\lambda_i,c_j),$

where $\lambda_i\in\mathbb{R}^{d_\lambda}$ is a learnable row embedding, $c_j\in\mathbb{R}^{d_c}$ is a learnable feature embedding, and $f_\theta$ is a shared small MLP (Ochs et al., 1 Oct 2025). In this formulation, the table is represented as a function over discrete row and column coordinates. The row embeddings are collected into $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$0 and the feature embeddings into $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$1.

The architecture follows the auto-decoder paradigm associated with DeepSDF. During training, the method jointly learns shared network parameters $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$2, row embeddings $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$3, and feature embeddings $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$4. For unseen rows at test time, $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$5 and $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$6 are kept fixed, while a new row embedding is optimized from partial observations. This is the basis of its instance-adaptive imputation mechanism.

The default network parameterization uses an MLP with typically 2 hidden layers, 256 units per hidden layer, SIREN activations, dropout $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$7, and a frequency parameter $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$8 for SIREN. Row and feature embedding dimensions are 32 in the default configuration. Hyperparameters are chosen via grid search, and ablations show that deeper and wider networks can improve performance on some datasets.

3. Data types, reconstruction objective, and optimization

TabINR uses a unified scalar-output formulation for numerical and categorical variables. Numerical features are kept as real-valued and each numeric column is scaled via min–max scaling during training. Categorical features are one-hot encoded. If an original categorical feature $\mathcal{D}\in \overline{\mathbb{R}}^{n\times m}$9 with $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$0 categories is expanded into a one-hot group $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$1, then all one-hot columns form $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$2. The model outputs a scalar per column; for one-hot columns that scalar is interpreted as a logit. At inference, each one-hot group is decoded with winner-takes-all by taking the $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$3 over the group.

Let

$\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$4

denote the set of observed entries. Training is performed only on $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$5, with a mixed reconstruction loss:

$\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$6

where $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$7 indexes numeric features, $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$8 indexes binary one-hot features, and $\overline{\mathbb{R}}=\mathbb{R}\cup\{\emptyset\}$9 is the logistic sigmoid (Ochs et al., 1 Oct 2025).

This objective has several immediate consequences. Missing cells do not appear in $\emptyset$0 and are therefore masked out of the loss. The procedure is self-supervised because the supervision signal comes entirely from observed table entries rather than from external labels. Optimization uses Adam with learning rate $\emptyset$1, cosine annealing, and early stopping based on validation loss. During training, the framework additionally applies random masking of 10–70% of entries to simulate missingness and improve robustness.

4. Instance-adaptive imputation for unseen rows

A central property of TabINR is that it imputes a new instance $\emptyset$2 without modifying the trained network or feature embeddings. If $\emptyset$3 is the set of observed features for the new row, the method introduces a new latent code $\emptyset$4 and solves

$\emptyset$5

Operationally, $\emptyset$6 and all feature embeddings $\emptyset$7 remain fixed, $\emptyset$8 is initialized randomly, and a few steps of gradient-based optimization are performed so that the network output matches the observed values of the new row (Ochs et al., 1 Oct 2025). After optimization, any feature, including unobserved ones, is imputed via

$\emptyset$9

This mechanism is the sense in which the framework is described as a generalizable INR. Classical INR work often represents a single signal, whereas TabINR uses a shared backbone plus per-row latent codes that share statistical regularities across rows and can generalize to unseen rows through latent optimization. The same function handles all cells in the table, enforcing a global mapping from row–feature interactions to values. Learnable row embeddings replace simple similarity heuristics, and learnable feature embeddings encode relationships between columns that are difficult to express in classical conditional-regression pipelines. The paper does not include extra priors or regularizers on $i$0.

5. Empirical evaluation

The reported evaluation covers 12 real-world UCI-style datasets spanning regression and classification, with sizes ranging from 308 (Yacht) to 20,640 (California Housing) and 20,000 (Letter), and with feature counts ranging from 7 to 57. Both numerical and categorical variables are included, with categorical variables one-hot encoded before modeling.

Missing data are simulated under three standard mechanisms. MCAR masks entries independently with probability $i$1. MAR masks some features according to a logistic model conditioned on an observed subset. MNAR extends MAR with additional Bernoulli masking conditioned on values themselves. Missingness rates range from 0.1 to 0.7, and the implementation of these mechanisms is adapted from HyperImpute.

The baseline set includes mean or mode imputation, KNN, MICE, MissForest, GAIN, and ReMasker. For numerical features, performance is measured by normalized RMSE, defined as per-feature RMSE normalized by feature standard deviation and then averaged. For categorical features, the metric is AUROC, treating each one-hot column as a binary prediction. For downstream classification, XGBoost is trained on fully imputed datasets and evaluated via AUROC (Ochs et al., 1 Oct 2025).

Across MCAR, MAR, and MNAR, TabINR is reported to be consistently among the top methods. It is often best on higher-dimensional datasets such as bike, spam, and letter, especially under MAR and MNAR. Under MCAR, performance differences are smaller, but it typically matches or slightly exceeds strong baselines. As missingness increases, all methods degrade, yet TabINR degrades more gracefully and remains in the top three across most datasets, even at 70% missingness. In MAR and MNAR, KNN and MICE degrade substantially, MissForest remains strong on small or mostly categorical data, ReMasker is the most competitive deep baseline, and TabINR generally yields lower NRMSE for numerical variables and similar or higher AUROC for categorical variables.

The downstream classification study covers five classification datasets—credit, letter, obesity, raisin, and spam—with target-column imputation. In that setting, TabINR plus XGBoost achieves the best AUROC on obesity and spam and is very close to the best on the remaining datasets. ReMasker sometimes wins, as on letter, and KNN is strong on some small datasets such as raisin. A direct TabINR-based classifier that treats the label as a feature to impute underperforms the two-stage “impute then XGBoost” pipeline.

6. Invariance, efficiency, limitations, and usage conditions

Because rows and columns in a table do not possess a natural order, permutation sensitivity is a natural concern. TabINR uses pure embeddings rather than positional encodings, and the reported experiments confirm that permuting feature order before training leaves NRMSE and AUROC nearly unchanged. This is presented as evidence that the framework is invariant to arbitrary permutations of rows and columns.

The runtime behavior is described qualitatively rather than through explicit big-$i$2 formulas. Training resembles fitting a modest MLP on $i$3 scalar targets, with row embeddings scaling with $i$4 and feature embeddings with $i$5. For rows seen during training, imputation requires only forward passes $i$6 and is reported as sub-0.25s per dataset in the experiments. For new rows, inference requires optimizing a latent vector of dimension 32 for a handful of iterations, which is still light relative to rerunning MICE or growing new forests. In the runtime comparison, mean or mode imputation is the fastest, TabINR and ReMasker both have sub-0.25s inference per dataset once trained, and KNN, MICE, and MissForest are noticeably slower, especially on higher-dimensional datasets.

Architectural ablations on the Letter dataset under MCAR 0.1 show that increasing depth from 2 to 10 layers improves NRMSE and AUROC before saturation or slight decline, increasing latent dimension up to 256 steadily improves NRMSE and AUROC, and increasing width from 64 to 1024 units improves performance until roughly 512–1024 units. Among activations, SIREN and HOSC/Wire outperform ReLU; HOSC yields the lowest NRMSE and SIREN the highest AUROC. This suggests that additional capacity is beneficial up to a point, although the reported default is chosen to balance stability and generalization across datasets.

The main limitations are tied to evaluation scope and deployment assumptions. The experiments use moderate-size UCI-like benchmarks with synthetically generated MCAR, MAR, and MNAR patterns rather than naturally occurring real-world missingness. The use of a common default architecture across all datasets improves comparability but likely underestimates peak per-dataset performance. The comparison set is solid but not exhaustive with respect to the latest end-to-end transformer-based tabular predictors. Future directions identified for the framework include explicitly handling non-random missingness, scaling to larger datasets, adding automated hyperparameter selection or meta-learning, and integrating tabular data with images or text in multimodal INR pipelines.

In practice, the method is most directly suited to tabular data with substantial missingness in the range 10–70%, especially when fast inference and instance-adaptive imputation are required. The reported workflow is to one-hot encode categorical variables, apply min–max scaling to numerical variables, train the shared INR with row and feature embeddings on observed entries, impute training-table missing cells by forward passes, optimize a new latent code for each unseen row, and then use the completed table with standard downstream learners such as XGBoost.