TableEG: Synthetic Error Generation in Tables

• TableEG is an instruction-tuned framework that generates synthetic yet realistic errors in relational tables while preserving two-dimensional structure and inter-cell dependencies.
• It employs a unified triplet formulation combining error generation, detection, and correction through natural language instructions and Markdown-serialized tables.
• Fine-tuned with LoRA on diverse real-world datasets, TableEG outperforms rule-based baselines and GPT-3.5 Turbo by closely mimicking authentic error patterns and distributions.

TableEG is an instruction-tuned framework for synthetic error generation in relational tables that uses LLMs to inject synthetic yet authentic errors into tabular data. It was introduced to address a persistent bottleneck in data cleaning research: numerous error detection algorithms exist, but the availability of diverse, real-world error datasets remains limited, while manual annotation is both time-consuming and inconsistent. TableEG learns from 12 real-world, manually annotated datasets spanning ten domains and generates errors in four major categories—outliers, missing values, rule violations, and pattern violations—while preserving two-dimensional structure and inter-cell dependencies such as functional dependencies or semantic relationships. In this role, it is positioned as a practical benchmark for subsequent error detection and correction tasks (Liu et al., 15 Jul 2025).

1. Definition and problem setting

TableEG is designed to bridge the gap between purely rule-based corruptions, which lack diversity, and authentic real-world error distributions, which are expensive to annotate. The framework treats synthetic error generation not as arbitrary perturbation of isolated cells, but as a table-level modeling problem in which row-column structure and cross-cell dependencies must be preserved. This emphasis is central to its claim of generating authentic errors rather than merely noisy variants of clean data.

The framework is trained on 12 real-world datasets spanning ten diverse domains. Examples listed for these tables include Rayyan, Company, Marketing, Movie, and Credit, with domains including Academic, Business, Finance, Hospitality, and Transportation. The stated objective is not only to synthesize plausible corruptions, but also to ensure that the resulting error patterns and column-wise error distributions faithfully reflect authentic error distributions. Experimental claims are correspondingly framed in terms of pattern similarity, distribution similarity, and downstream detector behavior, rather than only qualitative plausibility (Liu et al., 15 Jul 2025).

2. Triplet formalization of generation, detection, and correction

TableEG casts each table task as a triplet $(I, T, O)$. Here, $I$ is an instruction in natural language, $T$ is the input table serialized in Markdown, and $O$ is a structured output in JSON. The instruction $I$ is composed of three parts: a task description $d_\kappa$, an error-type description $d_E$, and a contextual suffix $d_s$. Examples given for these components include a task description such as “Error Generation: introduce realistic errors,” an error-type description such as “missing values in non-mandatory fields,” and a suffix such as “output JSON with row/column indices.”

The input table $T$ is constructed by sampling the annotated rows $j^{(s)}$ together with additional random rows $I$0, then merging and shuffling them in order to bound token length. The output $I$1 specifies, for each modified cell, its row index $I$2, column index $I$3, error type $I$4, erroneous value $I$5, and, when available, the original correct value $I$6.

The three principal task formulations are written as

$I$7

$I$8

$I$9

This formulation places error generation, error detection, and error correction within a single representational scheme. A plausible implication is that the framework is intended not merely as a generator of corrupted tables, but as a unified substrate for benchmark construction across multiple data-cleaning tasks (Liu et al., 15 Jul 2025).

3. Table-level fine-tuning strategy

The base model in TableEG is LLaMA 3.1–8B. Fine-tuning is performed with LoRA adapters applied to the projection layers $T$0. The training curriculum combines three error-related tasks—EGT, EDT, and ECT—with five “table-unrelated” tasks: row augmentation, column augmentation, swapping, filtering, header matching, and summarization. These auxiliary tasks are explicitly included to instill structural awareness.

The training corpus consists of 12 manually annotated real-world tables. The split is 90% train and 10% validation. The reported hyperparameters are: 3 epochs, LoRA rank 16, batch size per device 1 with gradient accumulation 16 for an effective batch size of 16, and AdamW with learning rate $T$1 and weight decay $T$2. The implementation uses 4 NVIDIA RTX A6000 GPUs with PyTorch 2.4.1 and CUDA 12.2.

The paper’s characterization of this setup as a table-level fine-tuning strategy is consequential. Rather than adapting an LLM only through textual instructions, the method explicitly couples instruction tuning with structured table serialization and task diversity. This suggests that TableEG treats structural competence over two-dimensional tables as a prerequisite for authentic error generation, rather than as a by-product of generic language modeling (Liu et al., 15 Jul 2025).

4. Generation pipeline and evaluation methodology

The end-to-end pipeline is organized into four stages. In Stage 1, the Prompt Builder extracts $T$3 triplets from the annotation corpus $T$4 using Algorithm 1, constructs instructions with Algorithm 2, and constructs input tables with Algorithm 3. In Stage 2, the Trainer fine-tunes the LLaMA base model with LoRA on these triplets. In Stage 3, the Error Generator, described as Algorithm 5, takes a clean table $T$5, a desired error ratio $T$6, an error-type distribution $T$7, and a model $T$8.

The generator computes

$T$9

allocates $O$0 across error types via $O$1, and then iteratively samples a subtable $O$2, builds an instruction $O$3 for a chosen error type $O$4, and infers $O$5. The parsed output yields $O$6. If $O$7 is unseen and $O$8, the error is applied to the generated dirty table $O$9 and recorded in the set $I$0. The algorithm returns $I$1 once the required number of errors has been generated.

Stage 4 is the Evaluator. It measures pattern alignment through Algorithm 8, producing $I$2, and distribution alignment through weighted Jaccard $I$3 and Jensen–Shannon divergence $I$4, in addition to downstream detection performance. For pattern alignment, TableEG uses hidden embeddings $I$5 from the $I$6th Transformer layer. For each generated error, it retrieves $I$7 nearest real-error pairs in embedding space and compares the transformation vectors

$I$8

with cosine similarity, taking the maximum over neighbors and averaging to obtain $I$9.

For column-level error distribution, the weighted Jaccard score is defined as

$d_\kappa$0

where $d_\kappa$1 and $d_\kappa$2 are the real and generated error proportions in column $d_\kappa$3. The Jensen–Shannon divergence is

$d_\kappa$4

These metrics formalize authenticity as geometric similarity of contextual transformations and alignment of column-wise error frequencies, rather than only exact cell-level matching (Liu et al., 15 Jul 2025).

5. Comparative results and benchmark behavior

The principal experimental comparison is against a rule-based baseline denoted BART and against GPT-3.5 Turbo without fine-tuning. For pattern alignment with $d_\kappa$5, TableEG achieves average $d_\kappa$6, compared with $d_\kappa$7 for BART and $d_\kappa$8 for GPT-3.5 Turbo. The gains are reported as consistent across both seen and unseen datasets, with Soccer and Restaurant named as examples.

For column-level distribution alignment, two explicit examples are provided. On the Flight dataset, TableEG attains $d_\kappa$9, while GPT-3.5 reaches $d_E$0 and BART $d_E$1; for divergence, TableEG obtains $d_E$2, compared with $d_E$3 for GPT-3.5 and $d_E$4 for BART. On the Beers dataset, TableEG attains $d_E$5, compared with $d_E$6 for BART and $d_E$7 for GPT-3.5; the corresponding divergences are $d_E$8 for TableEG, $d_E$9 for BART, and $d_s$0 for GPT-3.5.

Downstream error detection is evaluated with Raha, Holistic, and Horizon using weighted precision $d_s$1, recall $d_s$2, and $d_s$3. Across Flight, Movie, Company, and Marketing, Raha on generated versus real data is reported at approximately $d_s$4, $d_s$5, and $d_s$6. Holistic and Horizon show similar relative gaps. The reported conclusion is that detectors perform nearly identically on TableEG-generated errors and on real-world errors, especially for machine learning based methods such as Raha. In the paper’s broader framing, TableEG-generated errors therefore function as a robust surrogate for expensive manual annotations in data-cleaning evaluation (Liu et al., 15 Jul 2025).

6. Role, constraints, and open directions

TableEG is presented as both an overview framework and a benchmarking substrate. Its benchmark value derives from the combination of table-level fine-tuning, structured triplet supervision, explicit control over error ratios and type distributions, and evaluation against authentic datasets. The paper’s overall conclusion is that it bridges the gap between synthetic and real-world errors while establishing a robust benchmark for error detection and correction tasks.

The stated limitations are also specific. First, the framework relies on user-specified error ratios $d_s$7 and error types; future work is described as aiming for adaptive ratio prediction. Second, token-length constraints still require sub-table sampling, and scaling to very wide tables remains open. Third, current instruction templates are hand-crafted, and the paper identifies automating template design or meta-learning new instructions as possible routes to improved generalization. Fourth, the current formulation targets cell-level errors; extending to row-level or table-level corruption such as record duplication or deletion is left for future study.

These limitations delimit the current scope of the system. They suggest that TableEG’s fidelity claims are strongest for controlled cell-level corruption under specified error budgets, with realism demonstrated by alignment to observed patterns, distributions, and detector behavior rather than by unconstrained generation of every possible data-quality failure mode (Liu et al., 15 Jul 2025).