acceptodds
Under review as a conference paper at ICLR 2027

A Universal Schema for Relational Foundation Models

Abstract

Traditional relational deep learning models use a database's relational structure to predict properties of its entities for a given task specification, but are tied to the schema and task on which they are trained. Recent work on relational foundation models aims to remove this constraint by pretraining a single model across databases and transferring it to unseen ones. Existing approaches address schema variation through the model architecture. We propose a complementary, representation-level approach: an information-preserving mapping that represents any database and task using a fixed universal schema, moving schema agnosticism from the model architecture to the input data. Any existing relational deep learning model can then be trained across databases and transferred to new ones. On RelBench classification and regression tasks, we show that key relational foundation-model capabilities can emerge from this representation alone. A standard GraphSAGE trained across databases achieves zero-shot transfer to an unseen database under the Relational Transformer protocol, while transferred models require substantially fewer examples to reach a given accuracy when fine-tuned on a new database. Overall, our results suggest that relational foundation-model capabilities need not be encoded entirely in specialized architectures: they can emerge from the representation itself, enabling a modular interface between relational data and learning architectures.

Primary area:
foundation or frontier models, including LLMs
Keywords:
relational deep learning, relational databases, relational foundation models, zero-shot transfer

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_a5QYOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
3(+1)
Read review
Paper summary

Every database is mapped into one fixed "meta-schema" with everything (tables, columns, references, cells) stored as data -- reification, essentially -- and a standard heterogeneous GNN is then trained across databases and applied to unseen ones. The claim is that foundation-model capabilities (zero-shot transfer, label-efficient fine-tuning) emerge from this representation alone, with unchanged GNNs matching or beating the custom relational foundation models on RelBench, following RT’s leave-one-database-out protocol (the model gets the entity’s past labels, “self-labels”, as RT does, plus a one-sentence task description that RT doesn’t get).

This is a very straightforward and somewhat provocative idea - a bit like saying "just turn RDL into knowledge base completion over triplets and it works better (so why bother with RDL?)" - and I’d guess many people had it and dismissed it, since it breaks the core structural character/bias of the data-model match that the whole heterogeneous-GNN story of RDL is built on. And here it is presented very nonchalantly, in the standard method-experiments-ablations form, as if nothing happened... so I’m somewhat suspicious.

  • I’m not surprised it doesn’t fall to zero (even propositionalization itself is pretty strong on RelBench), but beating SotA like this seems either like some data leakage, or an artifact of the benchmark/evaluation itself (the likely option, see below).
Critical strengths
  1. The idea is clean and easy to understand, nothing gets invented architecturally, and code is linked (not checked). If the result holds, any existing RDL model becomes transferable for free, which sounds promising (I'd say).
  2. The limitations are stated honestly (single seed, data versions, the task text RT doesn’t get), so the concerns below are still answerable in a rebuttal (with ablations).
Critical weaknesses
  1. What really transfers is likely not the representation but the self-labels + task text, and that rather tells more about RelBench (a classic weakness, also reported in previous works) than about the representation. The Entity Mean/Median baseline, i.e. just the entity’s own label history, is on par with you on regression and close on classification on average :) - and RT is apparently just bad on regression in general (below the baseline in Tab. 1), so "surpassing RT" there means little, I think. Your ablation (Fig. 3) then shows the task text has by far the largest effect, while the schema names have none at all and the statistics little on average - i.e. the model doesn’t seem to read any schema semantics, it uses the schema tuples merely as bare connectivity - so "schema variation moved into the data" -- technically yes, but the model mostly ignores it, which kind of breaks the main point of the paper... This could be resolved with an ablation removing the self-labels (and both self-labels and task text together), or vice versa - keep only those two without the graph and see if it drops. Plus the original-schema baseline in the fine-tuning comparison "reads neither the task text nor the self-labels" doesn't look like a fair comparison, no?

  2. Overclaiming -- with a single seed (and the ~1 AUROC run-to-run variation you mention), the results are “comparable to RT” on classification, not “match or surpass” (on regression you do beat it, but see point 1 - RT is below the trivial baseline there; Griffin is clearly behind, fair). Similarly, the “contrast” with the complex architectures is overstated - relational transformers are schema-agnostic by design in the same reification sense (everything embedded at the cell level), so the two seem closer than the text suggests, and the fixed meta-vocabulary idea has prior work (ULTRA for KGs, afaik, before the cited “concurrent” one).

Questions for authors
  • The self-labels -- are they filtered by the tuple time T, or by the end of the label window T+w? (a label for [T, T+w) is only known at T+w -- i.e., leakage for training rows if the former)
  • Can you do the zero-shot without self-labels and without the task text (and/or the no-graph version)? -- this decides it for me (either way).
  • And the original-schema fine-tuning baseline with self-labels added...

Suggestion: the actually interesting finding here is that plain message passing over such reified graphs doesn’t lose on RelBench - I’d say that openly from the start, with what it implies about the benchmark...

3 comments
AuthorsOpenReview ↗

Response to Reviewer a5QY (1/2)

Thank you for a highly useful review. We ran the experiments you asked for. They helped us sharpen the claims.

Q2 / W1 (what transfers). We removed the database: the model sees only the entity's self-labels and the task text, with the same model, tasks, and budget. On average, the self-labels alone seem to match the full model. Per task, the picture splits in two. Where the label history is highly predictive, the database adds nothing and can even lower the score. Where it is weak, the database raises the score, sometimes by a lot: +5.8 (RelGT) and +10.6 (GraphSAGE) on Trial study-outcome, and +7.5 and +3.4 on Avito user-clicks. So the experiment says something about RelBench, and also about the universal schema: where the label history is not enough, a standard GNN trained on other databases makes use of a database whose schema it never saw.

Mean AUROC over the 12 held-out tasks:

  • RelGT: 70.8 with the database, 71.6 without.
  • GraphSAGE: 71.6 with the database, 70.5 without.
  • Entity Mean: 67.3.

Task text. The task text matters less than the ablation suggests. Fig. 3 masks it at inference, in a model trained with it. Trained without it, GraphSAGE reaches 70.7 instead of 71.6 and RelGT 68.4 instead of 70.8.

Relational transfer with no self-labels at all. This is your second suggestion: train and test without self-labels and without task text. Without both, the model has no way of knowing what to predict: a task and its negation would get exactly the same input. So the model must be told the task in some other way, and it must be one that reveals nothing about the entity being predicted, so that the original concern does not return. We use 1,024 labeled examples of the task, taken from other entities, and the same examples for every prediction. Each example is embedded by the same GNN, and the prediction attends to these examples and their labels. Because they are identical for every entity, they cannot tell two entities apart. Any score above 50 AUROC must therefore come from the entity's own data in the mapped database. To keep RelBench out of training entirely, we trained on 22 databases from The Join, none from a RelBench source, and tested on all of RelBench. Following Reviewer UMzU's concern, the checkpoint was also chosen on other Join databases that are never evaluated, so no RelBench label is used for training or for selection.

Mean AUROC is 64.2 with per-task checkpoint selection and 63.7 with this target-blind selection. The 14 points above 50 come from reading a mapped database the model never saw. Outside F1 and Event, the two databases where label history dominates, this model reaches 66.9, level with the self-label models (67.1) and above Entity Mean (65.4), with no label history of the entity at all.

With your agreement, we would be glad to add these experiments to the paper, and we would welcome any other control you consider informative.

AuthorsOpenReview ↗

Response to Reviewer a5QY (2/2)

W1 (schema semantics, Fig. 3). For RelGT, we agree with your reading. We ran the same ablation on GraphSAGE, and there the schema carries more. Masking the task text costs less (1.8 AUROC, against 4.3 for RelGT). Masking the schema names costs 0.9 on average, and dropping the schema tuples costs 2.2 on average. We will add this ablation next to Fig. 3.

Q3 (fine-tuning baseline). Agreed, the baseline lacked both inputs. We ran the one you asked for, and the conclusion holds: with matched inputs, the pretrained model still learns faster than training from scratch, on either schema. On the original schema with self-labels and the task text added (RelGT), these inputs help the baseline, mostly on regression, but the pretrained model stays ahead: 73.8 vs. 70.4 AUROC at 128 steps and 75.0 vs. 72.9 at 256 steps. On the same universal schema and inputs, pretrained vs. random initialization gives +6.4 AUROC at 128 steps for RelGT (73.8 vs. 67.4), +8.0 for HGT and +1.6 for GraphSAGE. At fixed numbers of distinct labels the picture is the same: with 256 labels the pretrained model reaches 73.7 mean AUROC against 69.6 and 69.5 for the two from-scratch baselines (see our reply to Reviewer UMzU, Q3).

Q1 (self-label time). There is no leakage here: a self-label is used only if its timestamp is strictly before the prediction time, and because RelBench spaces all of a task’s timestamps at least one label window apart, every such label’s window has already closed at prediction time (see experiments/data/self_labels.py:191 in our repository and relbench/base/task_base.py:107-144 in RelBench).

W2 (overclaiming). Accepted. A second seed for all three models moves the means by at most 0.4, so we will write "comparable to RT", not "match or surpass". On the contrast with RT: both are schema-agnostic at the cell level, but we encode this in the data rather than the architecture, so a standard GNN can be used. We will tone the contrast down and cite ULTRA as earlier work on a fixed vocabulary for knowledge graphs.

Suggestion. We will do this. The introduction will say that plain message passing over the reified graph does not lose on RelBench, and that under RT's protocol the label history alone matches the full model on average. RT's own ablation points the same way. With the experiments above in the paper, the setting without self-labels becomes the stronger test of transfer.

I appreciate the detailed replies and results, and I believe they largely support my interpretation that most of the transfer is the label history (only when it's weak, the representation adds a bit, granted). The experiments without self-labels are very nice (likely the only real test of transfer), thanks. It's also good to see the benefits of fine-tuning given matched input info. Also the self-label timing concerns are gone, so I'm increasing my rating of soundness. Overall, I see this as a nice, extensive experimental analysis of what actually transfers on RelBench (and of its weaknesses), rather than some breakthrough representation idea though, which I find somewhat less striking/impactful than what the paper framing suggests.

Reviewer_UMzUOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a fixed universal schema that represents database schemas, rows, typed values, foreign-key references, timestamps, and prediction tasks as data. This representation allows ordinary schema-specific relational models to share parameters across databases with different schemas. The structural mapping preserves information up to key renaming, although the numerical normalization used in practice is not invertible. Experiments instantiate the approach with GraphSAGE, HGT, and RelGT on 21 tasks from seven RelBench databases. Using leave-one-database-out pretraining, the authors report transfer without target-task weight updates, aggregate performance comparable to the Relational Transformer (RT), and faster early-stage fine-tuning.

Critical strengths

S1. A useful separation between database representation and learning architecture.

Sections 3.2–3.3 provide a concrete interface that encodes schema variation as data while retaining relational structure, typed values, temporal information, and task specification. This enables parameter sharing without requiring a new backbone for each source schema. The consequential contribution is a reusable approach to building relational foundation models from established architectures.

S2. Substantive evidence that the approach works across multiple backbones.

The evaluation covers three architectures, seven held-out databases, and both classification and regression. Table 1 reports, for example, 71.6 mean AUROC for GraphSAGE versus 70.6 for RT, and 34.1 mean nMAE for HGT versus 39.0 for RT. These descriptive results, together with the adaptation curves, support the feasibility of useful transfer through a common representation. The contribution does not depend on a single favorable architecture or task.

Critical weaknesses

W1. The evaluation does not sufficiently isolate target-independent transfer or establish the comparative performance claims. Section 4.2 selects a checkpoint separately using each target task’s validation labels. Appendix D.1 also states that learning rates were selected using validation results from Amazon, Stack, and H&M, which are subsequently included among the held-out evaluation databases. Thus, the results demonstrate transfer without target-task gradient updates, but model selection still uses target supervision. I recognize that target-specific checkpoint selection follows RT’s evaluation protocol; nevertheless, this limits conclusions about deployment on a genuinely unseen task without labeled validation data.

Furthermore, the comparison uses different input information and database versions: the proposed models receive task descriptions, RT receives other entities’ labels, and some published baseline results predate dataset corrections (Section 4.4 and Appendix D.3). Each result is a single run, while the reported classification advantages over RT—0.2–1.0 AUROC points—are comparable to the approximately one-point run variation acknowledged by the authors. These issues do not negate the feasibility result, but they leave the strength and attribution of the claimed gains uncertain.

W2. The label-efficiency experiments do not cleanly distinguish reduced labeling requirements from faster optimization and richer inputs. Appendix D.5 defines the label budget as optimizer steps multiplied by batch size. This does not establish a budget of distinct labeled examples, nor does it account explicitly for labels accessed through historical self-labels or regression-target normalization. The results therefore support faster early adaptation more directly than reduced annotation requirements.

Additionally, the headline improvements of 4.0 AUROC and 5.0 nMAE points after 128 steps compare pretrained universal-schema RelGT against scratch training on the original schema. Appendix D.6 specifies that the latter receives neither task descriptions nor self-labels, so this contrast changes initialization, representation, and available information simultaneously. The paper does include scratch-on-universal-schema curves, which is valuable, but the prominently quantified improvement does not isolate pretraining. Matched-input comparisons under explicit distinct-label budgets would materially strengthen this central claim.

Questions for authors
  1. Clarification and robustness check: How does Table 1 change when checkpoint selection and learning-rate selection use only source databases, with the target database excluded from all selection decisions?

  2. Clarification: For held-out regression tasks, which labels are used to fit the quantile transformation and invert predictions? Does this require the full target-task training-label distribution? How are these labels and historical self-labels counted in the stated label budgets?

  3. Evidence needed for the current claim: At fixed budgets of distinct target labels, what is the early adaptation advantage of pretrained versus randomly initialized models using the same universal schema, task descriptions, and permitted self-labels? Can this comparison be reported with repeated runs?

  4. Evidence needed for the comparative claim: Do the principal conclusions relative to RT persist across repeated runs under aligned dataset versions and clearly matched—or explicitly separated—input-information conditions?

3 comments
AuthorsOpenReview ↗

Response to Reviewer UMzU (1/2)

Thank you for the precise review. We ran each check you asked for, and our main conclusions hold. Following your suggestions, we will make three changes in the paper: (a) Table 1 will be reported with the checkpoint selected both with and without target labels; (b) the main fine-tuning result will compare our model and the baselines with matched inputs; and (c) results will be reported over repeated runs with different seeds, and we will describe them as "comparable to RT" rather than "match or surpass".

W1 / Q1 (choosing the checkpoint and learning rate without target labels). With the checkpoint chosen by the mean validation score of the training tasks only, mean AUROC drops from 71.6 / 71.4 / 70.8 to 65.2 / 65.5 / 66.2 (GraphSAGE / HGT / RelGT). This departs from RT's protocol, so these numbers cannot be compared to RT's published ones. The full paper will report both.

Another experiment shows that a model generalizes also when the checkpoint is selected without target labels (described in our reply to Reviewer a5QY Q2/W1). There, the task is given as labeled examples of other entities. The model is trained on 22 databases from The Join, and its checkpoint is chosen on other Join databases, so no RelBench label is used for training or for selection. It reaches 63.7 mean AUROC on RelBench, against 64.2 when the checkpoint is chosen per target: a gap of only 0.5 points. So the way the checkpoint is chosen has an impact on the reported score, and choosing it well without target labels is an interesting open question. It does not change the conclusion that the models transfer: in this experiment the model sees no label of the entity it predicts, and a model that ignores the database is at 50.

Learning rate selection. The labels of the evaluated databases did not help us in choosing the learning rate, and for the final version we will choose it only on databases that are never evaluated. The rate was chosen once per architecture on the validation labels of Amazon, Stack and H&M. The other four held-out databases took no part in this choice. To check the remaining three, we repeated the RelGT sweep on a disjoint group (Avito, Event and F1), and it selects the same rate as the original group, 3e-3. The paper uses 3e-4 for RelGT: on the original group the three highest rates were tied on validation, within 0.2 points, and we kept the one our earlier runs used. The difference is small: at 3e-3, held-out AUROC is lower by 0.16 and 0.55 on the two groups, and regression MAE improves on 5 of the 7 held-out tasks. In the final version, the rate will be selected on RelBench V2 or The Join, and Table 1 reported under that protocol.

W1 / Q4 (run-to-run noise and the task text). A second seed gives 71.2 / 71.1 / 71.1 against 71.6 / 71.4 / 70.8, so the means move by at most 0.4, and we will write "comparable to RT" throughout. More seeds are running. They will not finish within the discussion period; the final version will report their mean and std, overall and per task.

Task Text. The task text is not what makes our models comparable to RT. Trained without it, GraphSAGE reaches 70.7 instead of 71.6, which still matches RT (70.6). RelGT is more sensitive to it and reaches 68.4 instead of 70.8. The HGT run has not finished yet; we will report it as soon as it does. Note also that RT reads other entities' labels, which our models do not. The paper will report these results for all three architectures.

Data versions. The one difference we know of is a single RelBench update (pull request 357), which removes the AcceptedAnswerId column from Stack and corrects the Event user-ignore labels. Our runs include it; the published RT and Griffin Stack scores predate it (Appendix D.3).

AuthorsOpenReview ↗

Response to Reviewer UMzU (2/2)

W2 / Q2 (regression labels). The quantile transform is fitted on the training-split labels of the held-out task, never on validation or test. RT does the same with the mean and std of the training split (its Section 3.1). The fixed-label runs under Q3 below fit the transform on the budgeted labels only. Self-labels come from the task's past labels, and we do not count them in any budget: they are part of the entity's own history, which is computed from the database itself and is available at prediction time even in a real-world scenario. We did not state this clearly, and we will.

W2 / Q3 (matched fine-tuning comparison). You are right that the paper's main fine-tuning result (Section 4.3) doesn’t cleanly distinguish reduced labeling requirements from faster optimization and richer inputs. The cleaner test of pretraining is the pretrained model vs. random initialization on the same universal schema, with the same task text and self-labels. Under this test, the paper's conclusion holds: the pretrained model learns much faster early on, and the from-scratch model catches up as training continues. This will become the main fine-tuning result of the paper. In numbers, at 128 steps the pretrained model leads by 6.4 AUROC for RelGT (73.8 vs. 67.4, ahead on 11 of 12 tasks), 8.0 for HGT and 1.6 for GraphSAGE; at 256 steps the leads are 4.0, 5.4 and 0.1.

Original-schema baseline with the same inputs. We also gave the original-schema baseline the same self-labels and task text (RelGT). At 128 steps, the pretrained model still leads it, by 3.4 AUROC (73.8 vs. 70.4), ahead on 9 of 12 classification tasks and 8 of 9 regression tasks. At 256 steps, the lead is 2.1 (75.0 vs. 72.9). The paper reported 4.0 at 128 steps against the baseline without these inputs.

Distinct labels instead of steps. You are also right that the budget counts optimizer steps: 128 steps draw 32,768 examples, but these are not distinct labels. We therefore reran fine-tuning at fixed numbers of distinct labels, and the advantage holds: the pretrained model is ahead at every budget, most clearly when labels are few. The budgets are 256, 1,024, 4,096 and 16,384 labels (or the full training split where it is smaller), on all 21 tasks (RelGT), with the regression transform fitted on those labels only. The two from-scratch baselines, on the universal and on the original schema, train on the same labels and inputs as the pretrained model. Mean AUROC over the 12 classification tasks (pretrained / scratch on the universal schema / scratch on the original schema):

  • 256 labels: 73.7 / 69.6 / 69.5
  • 1,024 labels: 74.0 / 72.3 / 71.6
  • 4,096 labels: 74.5 / 73.8 / 72.7
  • 16,384 labels: 76.7 / 75.9 / 72.8

On the same schema, the from-scratch model needs about 4,096 labels to reach what the pretrained model reaches with 256. Regression agrees: mean nMAE is 33.3 / 36.2 / 35.8 at 256 labels and 30.9 / 32.5 / 32.4 at 16,384.

Thank you for the clarifications and additional experiments. These substantially address my concerns about label efficiency and the benefits of pretraining. I will raise my rating to 3. Please incorporate these results into the revised paper and clearly acknowledge the remaining limitations in model selection and baseline comparisons.

Reviewer_ZafjOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a "universal schema" to which any relational database can be mapped, for it to serve as input to relational foundation models. This is achieved by storing both the schema (tables, columns, foreign keys) and the contents (rows, references, cells) in the same tables. Previously schema-specific models can then be trained across databases and transferred to new ones without changing the architecture. The approach is tested on RelBench classification and regression tasks (zero-shot transfer and fine-tuning), and finds that the models are comparable to purpose-built relational foundation models.

Critical strengths

S1. Elegant idea to have a universal schema allowing both potentially two-way translation and also transfer of models across databases with different schemas. This kind of mapping has the potential to allow more robust training and inference of these foundation models.

S2. The experimental evaluation is reasonably sized, both in tasks and datasets. Leave-one-database-out is classic and allows to test the transferability, and using the model trained on the universal schema as a pre-trained model allows to test the claimed better convergence. With some caveats, the results are promising.

Critical weaknesses

W1. The main issue is that the universality of the schema is slightly oversold. First, if the domains are transformed, then clearly this is not always fully recoverable (although it is admitted in the text). The time model (which, by the way, is outside the standard relational model) is restricted to additions, and not to updates or deletions. Removing key values and replacing them with rowid is also not universal, as in some real cases we have natural keys that can be found in other non-key attributes of other tables; these relationships that could be trained are then lost. Moreover there is no clear motivation for "universality" and why this is the way to do it. A simple serialization of the database in a single file respects the definition at the beginning of 3.2. In that sense, the definition is too weak, and so the solution chosen is not necessarily the only one. This has impacts on experiments: why not then test other mappings then as a "control"?

W2. The first thing that popped to mind when I saw the proposed schema is the way DBMS store their metadata, which is extremely similar, via catalog tables in which the table schemas, keys, foreign keys, are stored. Yet the paper does not even refer to this line of work, and whether the proposed schema uses some of the classic database techniques / properties.

Questions for authors

Q1. Why did you choose the mapping as defined in 3.2? In other words, what are its properties (equivalence, isomorphism) that make it a good choice? Was it tested experimentally against alternative mappings or validated theoretically?

Q2. Would the schema carry over to other types of tasks? I'm thinking of tasks like link prediction or multi-class classification, natural tasks on relational data (and generally present in RelBench).

3 comments
AuthorsOpenReview ↗

Response to Reviewer Zafj (1/2)

Thank you for the careful reading, and for the database perspective in particular.

W1 / Q1 (why this mapping, and what "universal" means). You are right that the paper is not precise enough here, and we will fix it. First, the term "universal" is defined as a property a schema may have. Many schemas indeed have this property, and the schema we propose is one of them. We call it "the universal schema" only for brevity, which wrongly suggests that it is the only one. Second, the paper mixes this schema with two optimizations that we made for a more efficient representation: dropping key values and storing numbers in normalized form. These make the mapping not reversible, but the schema does not require them: it can hold a database with no loss, including every key value and every original number. We will first present the reversible mapping, and then describe the optimizations separately. In detail:

Keys and normalization. In the reversible mapping, a key is stored like any other attribute, so its values are kept, and every number is stored as it is. The reconstruction is then exact, including natural keys and their matches with attributes of other tables. The optimized representation makes two changes for efficiency. It drops key values, because in the benchmark we use all keys are replaced by surrogate identifiers that carry no information. And it replaces each number with its quantile-normalized value, because the model reads only that. Neither is needed for the mapping. The paper presented them as part of the mapping, which made the mapping read as lossy.

Time. We agree that the time model is not part of the relational model. We adopt it from relational deep learning (Fey et al., 2024), where it is used by RelBench and by the models we compare to, and we inherit its limitation: a tuple exists from its timestamp onward, so updates and deletions are not covered. This is a limitation of the learning setting and not of our schema. The time model is used only to decide which tuples a prediction is allowed to see, while the mapping treats the database as static and carries over the timestamps it holds as they are. We will make this separation explicit in the paper.

The definition. You are right that the definition is very general. The notion of a universal schema plays no mathematical role in the paper and has no bearing on the quality of learning; it only gives a meaning to the term. Presenting it in the form of a definition is misleading, since, as you show, a serialization satisfies it. We will replace it with a plain explanation of what we mean by a universal schema. As for why this mapping: we designed it to be not only universal but also suitable for learning. For example, the schema becomes data the model can read, and tuples, values, and references stay linked by foreign keys, so existing relational models run on it unchanged, with a tuple's values one hop away and the tuples it references two hops away. We do not claim it is the only or the best such design. Comparing different schemas is interesting future work, which could also tell us which properties of a schema matter, both for generalization across databases and for learning on a single schema.

Controls. We did not compare families of mappings, and we agree this is a natural experiment for future work. While designing the schema we ran a few experiments on variations of the mapping. For example, an early version represented a foreign key only at the schema level, with one tuple per foreign key, and it did not support relational learning; adding the Refs relation, with one tuple per reference between two rows, was needed to let information flow between related rows. We also checked that the mapping does not harm learning: training the same model (RelGT) from scratch on our universal schema and on the original schema, with exactly the same inputs, gives comparable accuracy (77.6 vs. 75.5 mean AUROC over the 12 classification tasks).

AuthorsOpenReview ↗

Response to Reviewer Zafj (2/2)

W2 (DBMS catalogs). Thank you. We cite related representations (EAV and the direct mapping to RDF), and system catalogs belong with them; we will add the reference. A catalog stores the schema as data in fixed relations, much like our Tables, Columns and FKs. It is not universal in our sense, however: only the schema is stored this way, while the data itself stays in tables specific to each database. We store the data in fixed relations as well (Rows, Refs, and the cell relations), so the entire database is over one fixed schema.

Q2 (other tasks). Multi-class classification fits the definitions as they are, with integer labels, and needs only a different output head. Link prediction asks for a reference between two tuples, i.e., a Refs tuple; this needs the task definition extended to a target with two references. We evaluated neither, because our evaluation follows RT's protocol, which covers binary classification and regression only. Extending the approach to these tasks is an interesting direction for future work.

Thank you for the detailed answer. I think that these limitations should be (or should have been) clearly stated in the paper, so I encourage the authors to add this to the next version of the paper.

Concerning the comment on comparing other control mappings in future work: I think this is absolutely necessary as even a softened "universality" claim cannot hold without establishing the proposed mapping as necessary.

All in all, I maintain my current (slightly positive) assessment, as I think it represents fairly the current state of the paper.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.