A SQL-based method for choosing which paths through relational data to keep was associated with markedly faster relational deep-learning training in benchmark tests, according to a new preprint. The authors report MetaSieve as the fastest per-epoch, or per-training-cycle, strategy for classification and say the comparison did not come with an accuracy cost. They cite a beer-churn comparison on RelGT with a speedup of more than 10 times.
The benchmark behind the comparison
The evaluation was an offline computational comparison across five RelBench relational databases: rel-ratebeer, rel-trial, rel-f1, rel-stack and rel-avito. It used standardized training, validation and test splits for node-level classification and regression tasks. For each dataset and GNN backbone, the strategies were run for the same number of epochs. Regression comparisons included random sampling and MetaSieve only, because MPS-GNN does not support regression.
MetaSieve scores candidate metapath extensions—possible routes through linked records—according to task relevance, sampling cost and support. Extensions with low scores are converted into pruning rules for downstream GNN sampling. The paper frames this as a way to reduce the size of relational training subgraphs before model training.
The speedup was clearest in classification
Across the reported classification comparisons, MetaSieve was the fastest strategy per epoch while predictive accuracy was generally maintained or sometimes higher. The cited beer-churn result on RelGT exceeded a 10-fold speedup. No confidence intervals or run-to-run variability were reported, so the findings are point comparisons rather than a quantified range of expected performance.
Regression was faster but less uniform on accuracy. In the rel-ratebeer/user-count task, HeteroGraphSAGE took 890 seconds per epoch with random sampling and 220 seconds with MetaSieve; its MAE, or mean absolute error, was 7.991 and 7.651, respectively. For HGT, the corresponding times were 3,740 and 736 seconds, while MAE moved from 12.431 to 14.447. The examples show why shorter training cycles and lower error did not move together across backbones.
Choosing paths has an upfront cost
MetaSieve preprocessing was dominated by SQL work. The remaining statistics, scoring and rule-generation steps took 5 to 36 seconds, and total preprocessing was described as a fraction of one RelGT random-sampling epoch. MPS-GNN, by contrast, was reported to take up to 45 epochs for preprocessing, while the GNN runs lasted at most 30 epochs. The authors judged that approach too slow in this setting.
That MPS-GNN comparison used a specially reduced search subset, so its overhead estimate is specific to the tested setup. A broader search also carried a penalty: retaining the top 30 metapaths instead of the default top 20 was accompanied by higher preprocessing and per-epoch times, while accuracy changes were mixed.
The details changed the balance
Ablation tests—comparisons that remove or simplify one part of a method—favored informed pruning. Random pruning performed worse in both reported outcomes, while the complete scoring formula produced the best accuracy among the tested variants. The threshold setting δ also affected pruning and performance for some tasks. Its value was selected using validation accuracy first and time per epoch second, while δ = 0.2 was considered a reasonable common default.
The simpler prefix-agnostic heuristic, which does not distinguish rules by the path prefix that led to them, generally avoided overpruning—the loss of potentially useful paths—in the tested settings. Overpruning was more noticeable in highly connected schemas and at deeper hops. Less aggressive alternatives changed predictive performance little but generally increased training time, making the heuristic a practical compromise within the benchmark.
Memory may be the harder constraint
When a single frontier—one intermediate set of materialized linked rows—was measured, resident-set memory rose approximately linearly with the number of child rows; the reported fitted slope was 1.01. In multi-worker execution, the rel-ratebeer/beer-churn run used four workers and 32 batches, reached 16.73 billion concurrent child rows and peaked at 1,040.22 GB of global resident memory over 1,436 seconds. The experiment ran on a machine with 2 TB of RAM and reported no out-of-memory failures, but the figures show why worker count and batching matter.
A promising result with a narrow test
The evidence is a set of point comparisons on the evaluated benchmark settings. The supplied analysis reports no confidence intervals or repeated-run variability, leaving the stability of the exact performance gaps unresolved. The comparison also leaves an important gap: MPS-GNN was not available as a regression baseline. Finally, δ was tuned task by task, so results can depend on validation choices.
The document is an arXiv preprint, version 1 dated 26 Aug 2026. It lists a GitHub repository for the MetaSieve source code. Its strongest reported case is faster classification training, while mixed regression results and potentially heavy memory use remain central cautions for interpreting the benchmark.
Paper data and sources
Original title: MetaSieve: Faster Relational Deep Learning through SQL-Based Metapath Selection
Authors: Fahim Shahriar Khan, Ashraf Aboulnaga
Journal/Repository: arXiv
Status: Preprint, not yet peer-reviewed
First online: 2026-08-26
DOI: Not available
Original paper · Full text