Instance Table: Semantic & Structural Analysis

• Instance Table is a structured data format where each row represents a semantic instance and columns denote its corresponding attributes.
• It facilitates the transformation of tabular data into RDF graphs through techniques like entity-focused completion and query-driven table synthesis.
• Recent methods integrate iterative ranking, ontology mapping, and geometric cell detection to enhance semantic interpretation and table reconstruction.

An instance table is a tabular representation in which rows denote instances and columns denote attributes or properties. In Tab2KG, it is defined formally as a data table $T$ whose rows each represent one semantic tuple of related entities and whose columns represent attributes of those entities; the goal is to transform such a table into an RDF data graph $G_D^T=(N_D^T,R_D^T)$ (Gottschalk et al., 2023). In adjacent lines of research, closely related structures appear as entity-focused tables, where the leftmost column contains distinct entities and the remaining structure supplies headers and optional caption context, or as generated relational tables whose rows are core-column entities and columns are heading labels (Zhang et al., 2017, Zhang et al., 2018). The notion therefore spans table completion, semantic interpretation, query-driven table synthesis, and document-level table cell localization.

1. Formalizations of instance tables

A precise formalization appears in Tab2KG. There, an instance table $T$ is an $M\times N$ matrix, each cell $T_{m,n}$ contains a literal value, each row $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$ is viewed as one instance, and each column $c_n$ gathers all values $T_{1,n},\dots,T_{M,n}$ and corresponds to one data-type or object-property in the target ontology (Gottschalk et al., 2023). This representation is explicitly semantic: the table is not merely a storage layout, but an intermediate artifact from which a structured graph is materialized.

A different but compatible formalization is used in EntiTables. The table is entity-focused and written as

$$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$

with caption $c$, column-header labels $G_D^T=(N_D^T,R_D^T)$0, and leftmost-column entities $G_D^T=(N_D^T,R_D^T)$1, all distinct (Zhang et al., 2017). For the row-population task, the non-leftmost cell values $G_D^T=(N_D^T,R_D^T)$2 are ignored, which makes the instance-table abstraction explicitly partial: the model exploits the instance set, schema cues, and caption text rather than full cell contents.

On-the-fly Table Generation adopts a generative target object

$G_D^T=(N_D^T,R_D^T)$3

where $G_D^T=(N_D^T,R_D^T)$4 is an ordered list of core-column entities, $G_D^T=(N_D^T,R_D^T)$5 is an ordered list of heading labels, and $G_D^T=(N_D^T,R_D^T)$6 is the matrix of cell values with $G_D^T=(N_D^T,R_D^T)$7 the entry for entity $G_D^T=(N_D^T,R_D^T)$8 under attribute $G_D^T=(N_D^T,R_D^T)$9 (Zhang et al., 2018). This places the instance table at the output side of an IR pipeline: instead of interpreting a pre-existing table, the system assembles one from a keyword query.

These formalisms share a common structural premise: rows denote instance-bearing units, but they differ in what is taken as given. EntiTables assumes an incomplete but already entity-focused table; Tab2KG assumes a previously unseen data table with unknown semantics; on-the-fly generation assumes only a query and must construct the table itself. This suggests that “instance table” is best treated as a family of row-instance representations rather than a single operational definition.

2. Entity-focused completion and row population

EntiTables studies smart assistance for spreadsheet-like editing by concentrating on row population and column population for entity-focused tables (Zhang et al., 2017). For row population, the goal is: given $T$0, produce a ranked list of candidate entities $T$1 that might be added in row $T$2. The ranking criterion is the posterior

$T$3

yielding the scoring function

$T$4

The entity-similarity term $T$5 interpolates a knowledge-base estimate and a table-corpus estimate:

$T$6

The knowledge-base component is instantiated via relation overlap in the style of Bron et al., or via outgoing-link similarity, including Jaccard and WLM-style measures averaged over seeds. The corpus component is table co-occurrence:

$T$7

The column-header likelihood combines a language-model component with an exact-match component, and the caption likelihood treats the caption as a bag of words with interpolation between a KB abstract LLM and a table-corpus caption model (Zhang et al., 2017).

The implementation assumptions are explicitly interactive. The system indexes entities in column 1, column labels, and captions in the table corpus, along with outgoing links, category or type lists, and abstract terms in the KB. Candidate selection is reported at approximately $T$8–$T$9 ms, and ranking at approximately $M\times N$0–$M\times N$1 ms for $M\times N$2, allowing background updates to a suggestion drop-down while the user edits $M\times N$3, $M\times N$4, and $M\times N$5 (Zhang et al., 2017).

The empirical regime uses a Wikipedia table corpus of approximately $M\times N$6 M tables and DBpedia 2015 with approximately $M\times N$7 M entities. On row population with one seed entity, EntiTables reports MAP$M\times N$8 and MRR$M\times N$9, compared with a baseline MAP$T_{m,n}$0 and MRR$T_{m,n}$1; with five seeds, MAP increases to approximately $T_{m,n}$2 while MRR is approximately $T_{m,n}$3 (Zhang et al., 2017). The component analysis shows that KB-based similarity dominates single-component performance, corpus-based signals are complementary, and combining the three sources yields best accuracy.

A common misconception is that instance-table completion is reducible to entity-set expansion alone. The EntiTables decomposition contradicts that view: headers and caption are modeled explicitly, and the results indicate that the different signals are complementary rather than redundant (Zhang et al., 2017).

3. Query-driven construction of relational instance tables

On-the-fly Table Generation generalizes the instance-table setting from completion to synthesis: given a free-text query $T_{m,n}$4, the objective is to assemble a relational table whose entities are maximally relevant to $T_{m,n}$5 and whose schema covers the most informative and complete set of attributes for those entities (Zhang et al., 2018). The method decomposes the problem into three subtasks: core-column entity ranking, schema determination, and value lookup.

Entity ranking uses a learned linear model

$T_{m,n}$6

where $T_{m,n}$7 is the schema from the previous iteration. The features include Dirichlet-smoothed term-based matching between $T_{m,n}$8 and the entity’s all-text representation, DRRM_TKS deep semantic matching between the query and the entity description or property list, schema-assisted deep matching once a provisional schema is available, and Entity–Schema Compatibility (ESC), defined from a binary matrix $T_{m,n}$9 indicating whether an entity has a property in the KB or co-occurs with that heading in a table (Zhang et al., 2018).

Schema determination uses a symmetric ranking formulation for candidate labels $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$0:

$r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$1

Its signals include query-only column population, entity-assisted column population, DRRM_TKS matching between heading and query, Attribute Retrieval (AR), and an ESC variant for label ranking. Value lookup then fills each cell $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$2 from a catalog of observed facts extracted from the KB and the table corpus, prioritizing KB provenance and otherwise using the provenance table’s BM25 score for the query (Zhang et al., 2018).

A distinctive feature is iterative reinforcement between rows and columns. The algorithm initializes $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$3 and $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$4, then alternates entity and schema ranking for $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$5 iterations in practice before performing value lookup. This operationalizes the claim that entity selection and schema selection are not independent but can assist each other (Zhang et al., 2018).

The evaluation uses DBpedia 2015-10 and WikiTables, with query sets QS-1 and QS-2. For entity ranking, Round 0 query-only combined LM + DRRM_TKS gives NDCG@5$r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$6 on QS-1/QS-2, while Round 3 reaches approximately $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$7, corresponding to relative gains of $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$8 over Round 0. For schema determination, Round 0 combined performance is $r_m=(T_{m,1},T_{m,2},\dots,T_{m,N})$9 NDCG@5, increasing to $c_n$0 by Round 3. Value lookup exhibits complementary source dominance: on QS-1, KB-only MAP is approximately $c_n$1, table-corpus only approximately $c_n$2, and combined approximately $c_n$3 with MRR approximately $c_n$4; on QS-2, table-corpus only and combined are both approximately $c_n$5, while KB-only is approximately $c_n$6 (Zhang et al., 2018).

This line of work clarifies another misconception: instance tables in IR are not limited to retrieving existing web tables. The cited formulation explicitly generates a table in response to a query and populates rows, schema, and values jointly (Zhang et al., 2018).

4. Semantic interpretation without instance lookup

Tab2KG addresses a distinct problem: semantic table interpretation for tables with previously unseen data (Gottschalk et al., 2023). Its central claim is methodological rather than merely architectural: the system relies on lightweight semantic profiles only and does not require any instance lookup. This is particularly relevant for data analytics settings where data tables typically contain new instances.

The method constructs two profile spaces. Given a domain ontology $c_n$7, it collects for each data-type relation $c_n$8 the literals that occur in a representative domain knowledge graph and defines the domain profile

$c_n$9

where each $T_{1,n},\dots,T_{M,n}$0 is an $T_{1,n},\dots,T_{M,n}$1-dimensional feature vector over the literal values. For the input table, it computes one column profile $T_{1,n},\dots,T_{M,n}$2 per column and forms $T_{1,n},\dots,T_{M,n}$3 (Gottschalk et al., 2023).

Each profile contains five groups of features, with total dimensionality approximately $T_{1,n},\dots,T_{M,n}$4–$T_{1,n},\dots,T_{M,n}$5 per column or relation: fine-grained data-type flags; completeness measures such as number of values, number of non-null values, and number of distinct values; basic statistics; histograms; and quantiles. All literal values are cast into a numeric representation so that the same machinery applies to both domain and table profiles (Gottschalk et al., 2023). An ablation study reports that every feature group contributes non-redundant signal and that basic statistics are most critical.

Column–relation mapping is learned through a Siamese network implementing

$T_{1,n},\dots,T_{M,n}$6

Two identical feed-forward subnetworks with shared weights embed $T_{1,n},\dots,T_{M,n}$7 and $T_{1,n},\dots,T_{M,n}$8, the absolute difference vector $T_{1,n},\dots,T_{M,n}$9 is computed, and a final sigmoid layer outputs the similarity score. Training uses positive pairs from known table–graph triples, negatives sampled from the same ontology but absent from the gold mapping, binary cross-entropy loss, and early stopping; the best configuration reported is one hidden layer of size $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$0, learning rate $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$1, and batch size $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$2 (Gottschalk et al., 2023).

The mapping stage computes similarities only between matching coarse data types, retains either the top-$$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$3 candidates or those with similarity exceeding $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$4, and then applies a greedy one-to-one assignment between columns and ontology relations. Data-graph creation is then performed through RML materialization: one subject URI per row per main class is generated, column literals are attached as xsd-typed literal triples, and row-level instances are connected through the ontology’s object-property graph so that the RDF data graph is fully connected (Gottschalk et al., 2023).

The weather-observation example demonstrates the intended semantics of “previously unseen instances.” Values such as “cloudy,” “clear,” “rain,” and sensor labels “S1,” “S2,” and “S3” do not occur in the original domain knowledge graph, yet the system maps the columns to $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$5, $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$6, $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$7, and $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$8, then stitches together the class graph to obtain the correct RDF graph (Gottschalk et al., 2023).

On five benchmarks—GH, So, WA, ST, and SE—Tab2KG reports overall accuracy $$T=\begin{bmatrix} l_1 & l_2 & \dots & l_m\ e_1 & v_{1,2} & \dots & v_{1,m}\ e_2 & v_{2,2} & \dots & v_{2,m}\ \vdots & \vdots & \ddots & \vdots\ e_n & v_{n,2} & \dots & v_{n,m} \end{bmatrix},$$9, compared with $c$0 for DSL, $c$1 for DSL*, and $c$2 for T2KMatch on SE. Column–relation mapping accuracy alone on the GitHub test set is $c$3 (Gottschalk et al., 2023). An objective reading of these results is that instance lookup is not a necessary condition for high semantic-interpretation accuracy in previously unseen tables.

5. Cell instances and geometric structure in deformed tables

In document analysis, the term “instance” shifts from semantic rows to spatial cell objects. OG-HFYOLO treats deformed table cells as segmentation instances and targets fine-grained spatial coordinates of cells for downstream structure recognition (Liu et al., 29 Apr 2025). This use is orthogonal to row-instance semantics but remains part of the broader instance-table problem space because accurate cell localization is a prerequisite for reliable reconstruction of many real-world tables.

The model extends a YOLO-style segmentation framework with three key modules: a Gradient Orientation-aware Extractor (GOE), a Heterogeneous Kernel Cross Fusion (HKCF) block, and mask-driven non-maximum suppression. GOE is inserted immediately after the first downsampling and injects local edge priors into the feature stream. Given feature map $c$4, it computes learnable edge convolutions initialized as horizontal and vertical Sobel filters, a gradient magnitude map

$c$5

orientation channels

$c$6

and orientation-aware fusion

$c$7

which is added back into the backbone stream (Liu et al., 29 Apr 2025).

HKCF operates in the FPN-PAN neck. After channel reduction and channel-attention bridging, it applies parallel asymmetric convolutions $c$8:

$c$9

followed by residual fusion and channel restoration. The heterogeneous kernel selection protocol uses $G_D^T=(N_D^T,R_D^T)$00 at the shallowest level, then $G_D^T=(N_D^T,R_D^T)$01, then $G_D^T=(N_D^T,R_D^T)$02 (Liu et al., 29 Apr 2025). The stated purpose is to capture horizontally wide and vertically tall cell shapes and fuse cross-scale information.

For masks, OG-HFYOLO combines BCE and Dice into

$G_D^T=(N_D^T,R_D^T)$03

then adds scale-aware weighting using inverse area normalization and a logarithmic weight

$G_D^T=(N_D^T,R_D^T)$04

The total scale-aware loss up-weights smaller cells and down-weights larger cells in a controlled logarithmic manner (Liu et al., 29 Apr 2025). Post-processing replaces box-based NMS with mask-IoU suppression, directly addressing cases where adjacent cells have overlapping boxes but non-overlapping interiors.

The accompanying DWTAL datasets provide a benchmark for deformation-aware cell instance localization: DWTAL-s contains $G_D^T=(N_D^T,R_D^T)$05 images and DWTAL-l contains $G_D^T=(N_D^T,R_D^T)$06 images, with one wired table per image and pixel-level instance masks (Liu et al., 29 Apr 2025). On DWTAL-s, OG-HFYOLO reports BBox mAP@50 $G_D^T=(N_D^T,R_D^T)$07, BBox mAP@50:95 $G_D^T=(N_D^T,R_D^T)$08, Mask mAP@50 $G_D^T=(N_D^T,R_D^T)$09, and Mask mAP@50:95 $G_D^T=(N_D^T,R_D^T)$10; on DWTAL-l, the corresponding values are $G_D^T=(N_D^T,R_D^T)$11, $G_D^T=(N_D^T,R_D^T)$12, $G_D^T=(N_D^T,R_D^T)$13, and $G_D^T=(N_D^T,R_D^T)$14 (Liu et al., 29 Apr 2025). The ablation study attributes gains to GOE, HKCF, scale-aware loss, and mask-NMS, with all four modules together yielding a $G_D^T=(N_D^T,R_D^T)$15 gain in mask mAP@50:95 over baseline YOLOv5-Seg.

A plausible implication is that, for scanned or photographed documents, cell-instance segmentation and semantic instance-table interpretation are complementary layers: the former recovers geometric primitives, while the latter maps the recovered table into entities, attributes, and graph structure.

6. Evaluation regimes, limitations, and research directions

The empirical evaluation of instance-table methods varies sharply with the formulation of the task. EntiTables evaluates row and column population using simulated editing stages, with MAP and MRR as ranking metrics over entity completions (Zhang et al., 2017). On-the-fly Table Generation uses NDCG@5 and NDCG@10 for entity ranking and schema determination, and MAP and MRR for value lookup in generated tables (Zhang et al., 2018). Tab2KG evaluates semantic interpretation by overall accuracy of correctly identified data-type and class relations, while also isolating column–relation mapping accuracy (Gottschalk et al., 2023). OG-HFYOLO uses detection and segmentation measures such as mAP@50 and mAP@50:95 for bounding boxes and masks (Liu et al., 29 Apr 2025). The diversity of metrics reflects a deeper point: “instance table” research does not optimize a single objective, but a stack of objectives ranging from retrieval relevance to ontological correctness to pixel-level localization.

Several limitations recur across the literature. EntiTables notes that recall drops for “long-tail” or unique seed tables and suggests incorporating text or cell-value signals as future work (Zhang et al., 2017). On-the-fly Table Generation uses a fixed three-iteration termination criterion, relies on Wikipedia tables rather than noisier web-scale corpora, fills each cell from a single source, and uses string matching with manual synonym curation for schema normalization (Zhang et al., 2018). Tab2KG depends on representative domain knowledge graphs for constructing domain profiles and uses heuristic key-column detection when materializing RML mappings (Gottschalk et al., 2023). OG-HFYOLO is evaluated only on single-table images, has increased parameter count and GFLOPs relative to YOLOv5-Seg, and leaves multi-table layouts and un-wired tables for future work (Liu et al., 29 Apr 2025).

These limitations also delimit common misconceptions. It is not generally correct to assume that instance tables are fully specified objects awaiting only retrieval, because some systems complete partial tables and others generate them from queries (Zhang et al., 2017, Zhang et al., 2018). It is likewise incorrect to assume that semantic interpretation requires entity lookup, because Tab2KG is designed precisely for tables whose values are previously unseen (Gottschalk et al., 2023). Nor is it sufficient to treat table structure recognition as purely box detection when deformations are severe, because dense adjacent cells motivate mask-based reasoning at the instance level (Liu et al., 29 Apr 2025).

Research directions stated in the cited works suggest a convergence of currently separate strands. EntiTables points toward non-entity-focused tables and eventual cell-value imputation (Zhang et al., 2017). On-the-fly generation identifies convergence testing, large-scale runtime improvements, and more robust ontology alignment as open problems (Zhang et al., 2018). Tab2KG demonstrates a one-shot profile-based route to ontology mapping without instance lookup (Gottschalk et al., 2023). OG-HFYOLO proposes integrating logical row/column relationship inference directly into the mask head (Liu et al., 29 Apr 2025). This suggests that a fuller theory of instance tables would unify semantic instance modeling, query-driven assembly, ontology-grounded interpretation, and geometry-aware extraction within a single end-to-end framework.