1 Introduction↩︎

Tables organize information across scientific articles, financial reports, forms, and business documents. Table Structure Recognition (TSR) recovers this layout from document images and is central to document understanding [1], [2].

TSR [3]–[6] remains challenging because of its sensitivity to localization errors. Unlike generic object detection, small inaccuracies in row or column boundaries propagate into structural inconsistencies. Structure-aware metrics such as TEDS [7] and GriTS [8] penalize even minor boundary misalignments, so accurate TSR demands precise boundary localization rather than coarse object-level detection. Recent approaches leverage Transformer-based architectures and multi-stage pipelines [9]–[12] but their depth and post-processing hinder real-time deployment. Many also treat table elements via point-based or generic detection [13], [14], where boundary uncertainty and table-specific geometry are only implicitly handled. Boundary-aware modeling for joint localization and efficiency remains underexplored. We revisit TSR from a boundary-centric perspective. We model table elements as row-like and column-like objects with distribution-based boundary representations. This matches the elongated geometry of rows, columns, headers, and section separators. Distribution-based boundaries enable fine-grained refinement within a compact real-time architecture. We introduce an Edge-constrained Fine-grained Localization loss (EFL) that aligns refinement with table layout semantics: horizontal boundaries are emphasized for row-like elements, vertical ones for column-like elements (Figure 1). EFL guides refinement toward structurally meaningful adjustments at no inference cost.

We also address practical settings where large-scale annotations are scarce. Combining boundary distribution refinement with self-distillation, ConRTF maintains accuracy with small annotated tables.

The main contributions are:

• We reformulate TSR as a boundary-centric task with distribution-based boundary representations, enabling fine-grained localization and accurate structure recovery within a real-time architecture.

• We introduce EFL, which encodes table-specific geometric priors into boundary supervision via edge weights derived from an IoU-sensitivity analysis. EFL operates during training only, adding no inference cost.

• We demonstrate that the proposed approach is data-efficient, maintaining robust structural accuracy even when trained with only 2k–3k annotated tables, making it suitable for deployment under limited annotation budgets.

• We conduct extensive experiments on the large-scale PubTables-1M benchmark and two private datasets, evaluating performance using TEDS and GriTS metrics together with detailed runtime analyses, validating both structural accuracy and real-time efficiency.

2 Related Work↩︎

Table Structure Recognition. Table structure recognition (TSR) aims to recover the row-column layout of a table from its image. Early systems relied on ruling lines, whitespace analysis, and hand-crafted heuristics [1]. Deep learning methods have since replaced these pipelines, organized into three main families [2]. Detection-based methods treat rows, columns, and cells as objects, from Faster R-CNN [15] to DETR-style architectures on PubTables-1M [3], [13] and cascade detectors with tailored anchor ratios [14]. Sequence-based methods generate structure as token sequences, using HTML prediction [16], compact tokenizations [17], or pointer mechanisms [11]. Regression-based methods directly predict cell coordinates with self-supervised pre-training [12]. Despite this diversity, none explicitly encodes the geometric asymmetry between row-like and column-like elements into the training signal.

Real-time Object Detection. DETR [18] reformulated object detection as set prediction with a transformer, eliminating hand-crafted components such as anchors and non-maximum suppression. Deformable DETR [19] replaced dense attention with sparse deformable sampling, reducing convergence time by an order of magnitude. DINO [20] further improved accuracy through contrastive denoising training and mixed query selection. RT-DETR [21] introduced a hybrid encoder combining attention-based and CNN-based feature fusion, achieving real-time inference while matching DETR accuracy. D-FINE [22] builds on GFocal’s distribution-based regression [23], [24] with iterative refinement (FDR) and self-distillation (GO-LSD), setting a new accuracy-speed trade-off. In parallel, the YOLO family [25] has continued to push single-stage detection speed, with recent versions [26]–[28] approaching transformer-based accuracy. We build on D-FINE because its iterative refinement of distribution-based boundaries provides a natural entry point for encoding table-specific geometric priors.

Fine-grained Localization. Standard detectors regress bounding box coordinates directly, which can be imprecise for elongated or off-centered objects. Distribution-based methods [23], [24] model each boundary as a probability distribution over candidate offsets, improving robustness. D-FINE [22] extends this idea with iterative refinement and global self-distillation. However, these approaches treat all four edges symmetrically, regardless of geometry or semantic role.

Geometry-aware Loss Design. Incorporating geometric priors into loss functions has been explored in oriented object detection for aerial imagery. Yang et al. [29] model rotated boxes as Gaussian distributions with aspect-ratio-adaptive gradients, extended via Kullback–Leibler (KL) divergence [30]. ARS-DETR [31] explicitly introduces aspect-ratio-sensitive loss weighting for elongated objects. However, these methods target rotated bounding boxes. Table elements are axis-aligned but exhibit a different asymmetry: a row’s horizontal edges define inter-row boundaries critical for structure, while its vertical edges merely mark table extent. EFL addresses this edge asymmetry within a distribution-based refinement method.

3 Proposed Method↩︎

This section presents the proposed approach for real-time table structure recognition. We first reformulate TSR from a boundary-centric perspective, modeling table elements as row-like and column-like objects and representing their boundaries using distribution-based modeling (Section 3.1). We then introduce an Edge-constrained Fine-grained Localization loss that encodes table-specific geometric priors into boundary supervision (Section 3.2). Section 3.3 describes the complete ConRTF system.

3.1 Preliminaries: Distribution-based Boundary Refinement↩︎

We formulate TSR as the task of accurately localizing table element boundaries rather than detecting cells or generating structural sequences. This is motivated by the observation that most structural errors originate from imprecise row or column boundaries, where small localization deviations propagate into incorrect adjacency relationships. To enable robust localization, we represent each boundary as a probability distribution over candidate offsets. GFocal [23], [24] introduced this distribution-based regression, and D-FINE [22] extended it with iterative refinement and a non-uniform weighting function within a real-time DETR architecture [18], [21]. We adopt D-FINE as our base detector and review the key components. The first decoder layer predicts an initial bounding box \(\mathbf{b}^{0}=\{x, y, W, H\}\), where \(\{x, y\}\) denotes the box center and \(\{W, H\}\) the width and height. The center \(\mathbf{c}^{0}=\{x, y\}\) and edge distances \(\mathbf{d}^{0}=\{t, b, l, r\}\) from the center to the top, bottom, left, and right edges are derived accordingly. At the \(l\)-th decoder layer, boundary offset representations \(\mathbf{P}^{l}=\{P_t^{l}, P_b^{l}, P_l^{l}, P_r^{l}\}\) encode residual offsets with respect to \(\mathbf{d}^{0}\), as illustrated in Figure 2. The residual edge offsets are computed through a scale-aware transformation: \[\Delta \mathbf{d}^{l} = \{H, H, W, W\} \cdot f(\mathbf{P}^{l}), \label{eq:edge95refinement}\tag{1}\] where \(f(\cdot)\) denotes a distribution-to-offset transformation defined below.

Distributions are refined across decoder layers through residual logit accumulation rather than prediction from scratch: \[P^l(n) = \mathrm{Softmax}\!\left(\Delta \mathrm{logits}^l(n) + \mathrm{logits}^{l-1}(n)\right), \label{eq:residual}\tag{2}\] where each layer predicts incremental logits \(\Delta \mathrm{logits}^l(n)\) that correct the previous layer’s estimate, enabling coarse-to-fine boundary refinement.

\(f(\cdot)\) in Eq. 1 uses a non-uniform weighting function [24]: \[f\!\left(P^{l}\right) = \sum_{n=0}^{N} W(n)\, P^{l}_{n}, \label{eq:f95transform}\tag{3}\] \[W(n) = \begin{cases} -2a, & n = 0, \\[4pt] c - c\!\left(\dfrac{a}{c}+1\right)^{\frac{N-2n}{N-2}}, & 1 \le n < \dfrac{N}{2}, \\[10pt] - c + c\!\left(\dfrac{a}{c}+1\right)^{\frac{-N+2n}{N-2}}, & \dfrac{N}{2} \le n \le N-1, \\[10pt] 2a, & n = N, \end{cases} \label{eq:weighting}\tag{4}\] where \(n\) indexes the discrete spatial bins, \(N\) is the total number of bins, and \(a\) and \(c\) are hyper-parameters controlling the magnitude and curvature of the weighting function. The shape of \(W(n)\) is adaptive: near the center of the bin range (\(n \approx N/2\)), \(W(n)\) varies smoothly, enabling fine-grained adjustments for near-accurate predictions. Near the extremes, the curvature increases, providing flexibility for larger corrections.

D-FINE supervises boundary distributions with a Fine-Grained Localization (FGL) loss that encourages predicted distributions to concentrate on the ground-truth offset. For each of \(K\) matched prediction-ground-truth pairs (obtained via Hungarian matching [18]), the ground-truth relative offset \(\phi = (\mathbf{d}^{\mathrm{GT}} - \mathbf{d}^{0}) / \{H, H, W, W\}\) generally falls between two adjacent bins \(n_{\leftarrow}\) and \(n_{\rightarrow}\) in the warped space defined by \(W\). The total FGL loss sums over all \(L\) decoder layers, \(\mathcal{L}_{\mathrm{FGL}} = \sum_{l=1}^{L} \mathcal{L}_{\mathrm{FGL}}^l\), where: \[\mathcal{L}_{\mathrm{FGL}}^l = \sum_{k=1}^{K} \mathrm{IoU}_k \cdot \left( \omega_{\leftarrow} \cdot \mathrm{CE}(P^l(n)_k, n_{\leftarrow}) + \omega_{\rightarrow} \cdot \mathrm{CE}(P^l(n)_k, n_{\rightarrow}) \right) \label{eq:fgl}\tag{5}\] \[\omega_{\leftarrow} = \frac{|\phi - W(n_{\rightarrow})|}{|W(n_{\leftarrow}) - W(n_{\rightarrow})|}, \quad \omega_{\rightarrow} = \frac{|\phi - W(n_{\leftarrow})|}{|W(n_{\leftarrow}) - W(n_{\rightarrow})|} \label{eq:interp95fgl}\tag{6}\] where \(\mathrm{IoU}_k\) is the IoU between prediction \(k\) and its matched ground truth and \(\mathrm{CE}\) denotes cross-entropy. Each edge contributes to the loss with equal weight.

D-FINE additionally employs Global Optimal Localization Self-Distillation (GO-LSD) [22], which transfers refined boundary distributions from the final decoder layer to shallower layers through KL-divergence-based distillation. This stabilizes early-layer predictions and improves convergence, particularly under limited training data. We adopt GO-LSD unchanged from D-FINE.

3.2 Edge-constrained Fine-grained Localization Loss↩︎

The FGL loss defined in Eq. 5 supervises all four edges of each element with equal weight, which is appropriate for generic object detection where no edge direction is inherently more important. However, table elements exhibit a structural asymmetry that this uniform treatment ignores: row-like elements (rows, headers, section separators) are defined by their horizontal boundaries, while columns are defined by their vertical boundaries. Misaligning a row’s top or bottom edge corrupts the table structure more than a comparable error on its lateral edges, and vice versa for columns. Inspired by FGL, we propose an Edge-constrained Fine-grained Localization (EFL) loss that re-weights boundary supervision according to each element’s structural role. The total EFL loss sums over all \(L\) decoder layers, \(\mathcal{L}_{\mathrm{EFL}} = \sum_{l=1}^{L} \mathcal{L}_{\mathrm{EFL}}^l\), where: \[\mathcal{L}_{\mathrm{EFL}}^l = \sum_{k=1}^{K} \mathrm{IoU}_k \cdot \left( \boldsymbol{\omega}^*_{\leftarrow} \cdot \mathrm{CE}(P^l(n)_k, n_{\leftarrow}) + \boldsymbol{\omega}^*_{\rightarrow} \cdot \mathrm{CE}(P^l(n)_k, n_{\rightarrow}) \right) \label{eq:efl}\tag{7}\]

Compared to FGL (Eq. 6 ), EFL modifies the interpolation weights \(\boldsymbol{\omega}^*\) by introducing a class-dependent edge weight: \[\boldsymbol{\omega}^*_{\leftarrow} = \frac{|\phi - W(n_{\rightarrow})|}{|W(n_{\leftarrow}) - W(n_{\rightarrow})|} \cdot e_w, \quad \boldsymbol{\omega}^*_{\rightarrow} = \frac{|\phi - W(n_{\leftarrow})|}{|W(n_{\leftarrow}) - W(n_{\rightarrow})|} \cdot e_w \label{eq:interp95efl}\tag{8}\]

The loss in Eqs. 7 –8 is computed independently for each of the four edges, and \(e_w\) selects the corresponding scalar weight per edge direction. The edge weight vector \(e_w \in \{e_w^r, e_w^c\}\) is assigned based on the element class: \[e_w^r = [\lambda_{h}, \lambda_{h}, \lambda_{l}, \lambda_{l}], \quad e_w^c = [\lambda_{l}, \lambda_{l}, \lambda_{h}, \lambda_{h}] \label{eq:edge95weights}\tag{9}\] where the four components correspond to the top, bottom, left, and right edges, respectively, and \(\lambda_h > \lambda_l\) (Figure 1). Row-like elements use \(e_w^r\), receiving stronger supervision on their structurally defining horizontal boundaries, while columns use \(e_w^c\), prioritizing vertical boundaries. EFL is applied during training only and introduces no additional cost at inference.

The values of \(\lambda_h\) and \(\lambda_l\) can be derived from an IoU-sensitivity argument. For any table element, let \(S\) and \(L\) denote the short and long dimensions, respectively, with aspect ratio \(\mathrm{AR} = L/S > 1\). Defining edges run along \(L\) and bound \(S\), while extent edges run along \(S\) and bound \(L\). For rows, \(S\) is the height and \(L\) the width. For columns, the roles are swapped. The derivation is identical in both cases.

Consider an element with ground-truth dimensions \(L \times S\). If one defining edge is shifted outward by \(\varepsilon\) pixels, the predicted box becomes \(L \times (S + \varepsilon)\). Since the ground truth fits inside the prediction, \[\mathrm{IoU}_{\mathrm{def}} = \frac{S}{S + \varepsilon} = \frac{1}{1 + \varepsilon/S} \approx 1 - \frac{\varepsilon}{S}. \label{eq:iou95def}\tag{10}\] The same perturbation on an extent edge gives \(\mathrm{IoU}_{\mathrm{ext}} \approx 1 - \varepsilon/L\). Since \(S \ll L\), defining-edge errors cause \(\mathrm{AR}\) times more IoU degradation than extent-edge errors.

We model expected localization error on an edge as inversely proportional to its loss weight: defining edges (weight \(\lambda_h\)) have expected error \(C/\lambda_h\), extent edges (weight \(\lambda_l\)) have expected error \(C/\lambda_l\). Each element has two defining and two extent edges. Substituting into the IoU drops and summing (valid to first order for small perturbations), the total IoU degradation is proportional to \[f(\lambda_h) = \frac{1}{\lambda_h \cdot S} + \frac{1}{\lambda_l \cdot L}. \label{eq:iou95total}\tag{11}\] We minimize \(f\) subject to a budget constraint: the total supervision weight must equal FGL’s uniform total (\(2\lambda_h + 2\lambda_l = 4\), i.e., \(\lambda_h + \lambda_l = 2\)). Substituting \(\lambda_l = 2 - \lambda_h\), differentiating, and setting to zero gives \[\frac{1}{(2 - \lambda_h)^2 \cdot L} = \frac{1}{\lambda_h^2 \cdot S}. \label{eq:lambda95deriv}\tag{12}\] At the optimum, the marginal cost of shifting weight toward defining edges exactly equals the marginal cost on extent edges. Solving: \[\lambda_h^{*} = \frac{2\sqrt{\mathrm{AR}}}{1 + \sqrt{\mathrm{AR}}}, \qquad \lambda_l^{*} = \frac{2}{1 + \sqrt{\mathrm{AR}}}. \label{eq:lambda95opt}\tag{13}\] When \(\mathrm{AR} = 1\) (square elements), this reduces to \(\lambda_h = \lambda_l = 1\), recovering the uniform FGL loss. Since EFL uses a single \((\lambda_h, \lambda_l)\) pair across all element classes, the shared optimum is constrained by the least elongated class. Setting \(\lambda_h\) at the optimum of a highly elongated class would reduce \(\lambda_l\) to a level that degrades defining-edge supervision for less elongated classes. The concrete values are determined by the dataset aspect ratios and reported in Section 4.3.

3.3 Architectural Design and Optimization↩︎

ConRTF adopts the D-FINE architecture [22] with an HGNetv2-X backbone encoder and a Transformer decoder with \(L\) refinement layers. The total training loss follows D-FINE, combining classification, box regression, and boundary distribution supervision. The sole modification is the replacement of FGL (Eq. 5 ) with EFL (Eq. 7 ). GO-LSD self-distillation is applied unchanged.

At inference, boundary distributions are decoded into bounding boxes via Eq. 1 , producing detections for all element classes. Table cells are reconstructed by computing row-column intersections following TATR [13]. The inference pipeline is identical to D-FINE, incurring no additional cost from EFL.

8pt

8pt

4 Experimental Setting↩︎

4.1 Datasets↩︎

We evaluate on a large-scale public benchmark and two private datasets. Statistics are summarized in Table 1 and class distributions in Table 2. ConRTF detects four element classes that together define table structure. Rows and columns delineate the primary grid. Headers are the top row(s) containing column labels, detected as a distinct class from data rows. Section separators are full-width rows that span all columns, serving as group headings that partition the table into logical blocks. Data rows following a section separator are typically associated with it, though grouping conventions vary across layouts. For EFL supervision (Section 3.2), headers, rows, and section separators are treated as row-like elements, while columns form the column-like class.

PubTables-1M: We adopt PubTables-1M as the primary public benchmark for Table Structure Recognition. We apply dataset-specific preprocessing to ensure annotation quality. Top-level headers are grouped and treated as a single header. Tables with excessive overlap (IoU >= 0.3) of between row-like elements or between columns are excluded, along with tables smaller than 200\(\times\)​50 pixels or containing fewer than three structural elements. After filtering, the dataset contains 701,275 tables for training, 87,835 tables for validation, and 86,917 tables for testing. Since all methods are trained and evaluated on the same filtered splits, the results are directly comparable.

Business Dataset, consisting of 4,362 tables, with 654 tables used for testing. This dataset includes complex business tables with dense layouts and irregular structures, posing additional challenges for TSR.

Finance Dataset contains 2,769 tables, with 272 tables reserved for testing. The tables are extracted from structured financial documents and exhibit diverse header hierarchies and spanning patterns.

The use of in-house datasets alongside public benchmarks is established practice in TSR research: works such as TSRFormer [32] and RobusTabNet [33] validate on proprietary collections to test robustness under real-world conditions. PubTables-1M serves here as a fully reproducible public anchor, and the Business and Finance sets add domain diversity that public benchmarks alone do not cover.

4.2 Evaluation Metrics↩︎

We evaluate table structure recognition using two complementary metrics.

Tree Edit Distance-based Similarity (TEDS) [7] measures the minimum edit distance between HTML tree representations of predicted and ground-truth tables, normalized as \(\mathrm{TEDS} = 1 - d / \max(|T_{\mathrm{pred}}|, |T_{\mathrm{GT}}|)\), where \(d\) is the tree edit distance and \(|T|\) denotes the number of nodes. TEDS_Struct compares only structure (tags, row/column spans), while TEDS_Text additionally evaluates cell content through character-level edit distance.

GriTS [8] evaluates table structure through three complementary dimensions based on optimal grid alignment. Ground-truth and predicted tables are represented as cell grids, and the Factored 2D Most Similar Substructures algorithm aligns them along rows and columns via dynamic programming. Pairwise cell similarities are then aggregated into precision, recall, and F-score. The three sub-metrics differ in their similarity function: GriTS_Top compares cell topology (relative spans) via IoU, GriTS_Loc compares cell bounding boxes via IoU, and GriTS_Con compares cell text via longest common subsequence similarity. We report F-scores for all three sub-metrics.

4.3 Implementation and Training Settings↩︎

ConRTF adopts the D-FINE-X architecture [22]: an HGNetv2-X backbone encoder [34], followed by a 6-layer Transformer decoder with 300 object queries. Input images are resized to \(640 \times 640\). We optimize with AdamW using a learning rate of \(2.5 \times 10^{-4}\) (\(100\times\) smaller for the backbone), weight decay of \(1.25 \times 10^{-4}\), and gradient clipping at \(0.1\). Training uses exponential moving average (decay \(0.9999\)) and mixed-precision. Data augmentation includes photometric distortion, random zoom-out, IoU-based cropping, and horizontal flipping. We train for 20 epochs on PubTables-1M and up to 500 epochs with early stopping (patience 10) on the private datasets. All experiments run on a single NVIDIA A6000 GPU.

For the EFL loss (Section 3.2), we measure element aspect ratios from the training annotations. Rows exhibit \(\mathrm{AR} \approx 44\), headers \(\approx 35\), section separators \(\approx 10\), and columns \(\approx 2\). Applying Eq. 13 per class, the optima range from \(\lambda_h \approx 1.7\) for rows and headers to \(\lambda_h \approx 1.2\) for columns. Because EFL assigns a single weight pair to all classes, we adopt the column-constrained optimum \(\lambda_h = 1.2\), \(\lambda_l = 0.8\): this is the highest \(\lambda_h\) that does not degrade defining-edge supervision for the least elongated class. For rows and headers, this value is below their per-class optimum but still provides meaningful improvement over the uniform baseline (\(\lambda_h = \lambda_l = 1.0\)). The weighting function parameters \(a\) and \(c\) in Eq. 4 and all loss component weights follow D-FINE defaults. The D-FINE-X baseline uses the identical architecture and training protocol with standard FGL and uniform edge weights (\(\lambda_h = \lambda_l = 1.0\)), providing a controlled ablation that directly isolates the contribution of edge-constrained supervision. We compare against TSR-optimized RT-DETRv2-X [21], [35], YOLOv10-X [26], YOLO11-X [27], and YOLO12-X [28].

5 Experimental Results↩︎

We evaluate ConRTF on PubTables-1M and two private datasets (Business and Finance). The experimental design centers on isolating the effect of edge-constrained supervision: ConRTF extends D-FINE-X with EFL while preserving the identical architecture, training protocol, and hyperparameters, enabling a direct measurement of EFL’s contribution. Additional real-time baselines (RT-DETRv2, YOLOv10/11/12) provide broader context within the same speed class. We also analyze per-document score distributions and inference cost.

5.1 Performance Comparison on PubTables-1M↩︎

6pt

Table ¿tbl:tab:sota95pubtables-1m? compares ConRTF with real-time baselines on PubTables-1M. A clear performance gap separates DETR-based architectures from YOLO-based detectors. RT-DETR, D-FINE, and ConRTF all exceed 99% TEDS_Struct, while YOLOv10-X and YOLO11-X remain around 97%. The gap is most visible on GriTS_Con (92.6 and 90.9 for the YOLOs vs.+ for DETR-based methods), indicating that imprecise boundary predictions affect content-level cell matching more than topology. ConRTF improves consistently over D-FINE across all metrics, confirming that EFL provides a measurable benefit even above 99%. Beyond real-time detectors, ConRTF is competitive with sequence-based methods: its GriTS_Top of 99.51 slightly exceeds the vision-language model UniTabNet (99.43) [10], a result it achieves as a single-pass detector without the token-by-token decoding that such methods require.

Aggregate scores above 99% can obscure differences on the structurally complex tables that EFL targets. To quantify this, we isolate a hard subset of PubTables-1M where the D-FINE baseline scores below 99 GriTS_Con (\(n=4{,}322\), about 5% of the test set). On this subset ConRTF reaches 88.4 GriTS_Con against 85.8 for D-FINE, a gain of +2.6 points that is statistically significant (\(p=1.5\times10^{-120}\)). The same effect holds on the private datasets under the equivalent hard subset: +0.9 GriTS_Con on Business (\(n=294\), \(p=0.005\)) and +3.8 on Finance (\(n=112\), \(p=2\times10^{-4}\)). The gains concentrate on tables with ambiguous or complex boundaries, where precise edge localization is hardest.

5.2 Performance Under Limited Training Instances↩︎

To evaluate generalization under limited training data, we test on two private datasets: Business (3,054 training and 654 test tables) and Finance (2,123 training and 272 test tables). In both cases, test documents were drawn from an independent pool, separate from the training source, ensuring no data leakage between splits. Results are reported in Table ¿tbl:tab95private95performance?.

With limited training data, the gap between DETR-based and YOLO-based methods widens dramatically. On Finance, YOLOv10-X drops to 48.8% TEDS-_Struct, a 48-point deficit relative to PubTables-1M, while DETR-based models maintain above 92%. Notably, YOLO12-X’s larger capacity does not improve performance on these smaller datasets, where it generally trails YOLO11-X. This underscores the value of geometric priors over raw capacity: ConRTF’s gains come not from a larger model but from EFL’s targeted boundary supervision.

ConRTF outperforms D-FINE on both datasets across all metrics. The gains are notably larger on Finance (+1.02 TEDS_Struct, +1.29 GriTS_Con) than Business (+0.13, +0.11), and the score distributions in Table 3 reveal why. Business tables are denser (17.4 elements per table vs. for Finance, Table 2) with more section separators, producing more catastrophic structural failures: 10.7% of documents fall below 70% GriTS_Con, where the predicted structure fundamentally diverges from the ground truth. Finance has fewer such failures (6.6% below 70%) but a larger proportion of documents in the moderate band (21.3% vs.%), where errors stem from boundary imprecision rather than structural collapse. EFL directly addresses this through orientation-aware supervision, which is why the gains are largest on this dataset.

5.3 Score Distribution Analysis↩︎

Aggregate metrics can mask differences in per-document reliability. To complement the mean scores reported above, we analyze the distribution of per-document GriTS_Con scores across three performance bands: high (\(\geq 90\%\)), moderate (\(70\)–\(90\%\)), and low (\(< 70\%\)).

Table 3 compares ConRTF with D-FINE, its architectural equivalent trained without EFL. On PubTables-1M, both models concentrate almost all documents in the high band, consistent with their near-identical aggregate scores. On the private datasets, where the training data is two to three orders of magnitude smaller, ConRTF consistently shifts documents toward higher scores. The effect is most pronounced on Finance: ConRTF places 72.1% of documents above 90% compared to 68.7% for D-FINE (\(+3.4\) pp), while reducing the proportion below 70% from 10.7% to 6.6% (\(-4.1\) pp). These gains indicate that EFL’s orientation-aware supervision particularly benefits low-data regimes, where structural priors compensate for limited training signal (Figure 3).

10pt

5.4 Real-time Performance Analysis↩︎

Table 4 compares model complexity and inference speed across all methods. ConRTF and D-FINE-X share identical parameters (62M) and FLOPS (202G) because EFL operates only during training. The reported frames-per-second (FPS) values come from unoptimized PyTorch inference on an Intel Core i7-8850H CPU, a consistent setting for cross-method comparison: YOLOv10-X is fastest (2.0 FPS) with the fewest parameters (32M), while RT-DETRv2-X is slowest due to its larger architecture. On an NVIDIA RTX A6000 GPU, ConRTF reaches 15.42 FPS and matches D-FINE-X (14.61 FPS), which confirms that EFL adds no inference cost.

10pt

Figure 3 illustrates two failure modes that EFL helps correct. In the first example (a–b), D-FINE produces three low-confidence section detections that overlap with valid row boundaries, fragmenting the table structure and dropping TEDS_Struct to 0.37. ConRTF eliminates these spurious sections entirely, recovering all four data rows and raising TEDS_Struct to 0.84. In the second example (c–d), D-FINE produces overlapping row boundaries at the bottom of the table, generating duplicate row detections that corrupt the grid structure. ConRTF resolves these boundary ambiguities, recovering the exact table layout with perfect TEDS and GriTS scores. In both cases, the errors involve boundaries between row-like elements, precisely the edges that EFL emphasizes through stronger horizontal supervision.

6 Conclusion↩︎

ConRTF reformulates table structure recognition by modeling table elements as row-like and column-like objects with distribution-based boundary representations. The Edge-constrained Fine-grained Localization (EFL) loss embeds orientation-aware geometric priors into boundary supervision, with edge weights derived from an IoU-sensitivity analysis. EFL operates during training only and adds no inference cost. Experiments on PubTables-1M and two private datasets show consistent improvements under TEDS and GriTS metrics, with the strongest gains in low-data regimes. The algorithm targets axis-aligned layouts. Extending EFL to per-class or instance-adaptive edge weights and to extremely low-data or zero-shot settings are promising directions for future work.

References↩︎