Neural Graph Databases (NGDBs) facilitate complex logical reasoning over incomplete knowledge structures, yet their training efficiency and expressivity are constrained by rigid query-level batching and structure-exclusive embeddings. We present NGDB-Zoo, a unified framework that resolves these bottlenecks by synergizing operator-level training with semantic augmentation. By decoupling logical operators from query topologies, NGDB-Zoo transforms the training loop into a dynamically scheduled data-flow execution, enabling multi-stream parallelism and achieving a 1.8× - 6.8× throughput compared to baselines. Furthermore, we formalize a decoupled architecture to integrate high-dimensional semantic priors from Pre-trained Text Encoders (PTEs) without triggering I/O stalls or memory overflows. Extensive evaluations on six benchmarks, including massive graphs like ogbl-wikikg2 and ATLAS-Wiki, demonstrate that NGDB-Zoo maintains high GPU utilization across diverse logical patterns and significantly mitigates representation friction in hybrid neuro-symbolic reasoning.
Figures & tables
Figure 1: Task Illustration. Query embedding methods aim to answer multihop logical queries (A) by avoiding explicit knowledge graph traversal and executing the query directly in the embedding space by following the query computation plan (B). Operators are executed in the embedding space (C).
Figure 2: Evolution toward High-Throughput Asynchronous Pipelining. Training methods. (a) represents the naive training scheme; (b) shows the pre-sampling and pre-fetching optimization; (c) NGDB-Zoo’s operator-level approach breaks these constraints to enable fully overlapping stages, creating a dense execution stream that maximizes hardware saturation.
Figure 3: Overcoming Topological Rigidity. (Left): Query-level batching incurs high fragmentation overheads by segregating distinct query structures. (Right): NGDB-Zoo aggregates atomic operators into homogeneous Operator Pools for unified execution, eliminating structural constraints and saturating GPU cores.
Figure 4: Max-Fillness Dynamic Scheduling. By prioritizing operator pools with the highest workload, the scheduler maximizes GPU utils. This dynamic selection effectively unblocks dependent nodes, ensuring a continuous, high-throughput training stream.
Figure 5: Vectorized execution for Intersection/Union. By grouping operations into cardinality-based Equivalence Classes, we eliminate tensor misalignment. This enables perfectly aligned Vectorized Execution , replacing slow loops with dense matrix operations.
Figure 6: Illustration of the decoupled semantic integration strategy. By relegating the heavy text encoder (PTE) to an offline pre-computation phase and caching embeddings in GPU memory, NGDB-Zoo achieves minimal-overhead semantic fusion during training.
Dataset
Model
MRR (%)
TPut ( ↑ )
Mem (GB ↓ )
FB400k
GQE
35.84
24.68
7.5
Q2B
52.33
21.55
11.0
BetaE
50.40
19.97
14.0
ogbl-wikikg2
GQE
32.88
23.92
8.0
Q2B
42.01
20.75
11.0
BetaE
44.54
19.65
14.0
Table 1: Scalability and Predictive Performance on Massive Knowledge Graphs. We report the filtered MRR (%), training throughput ( 103 Queries/sec), and peak GPU memory occupancy (GB) across three production-scale datasets. NGDB-Zoo enables high throughput and robust reasoning across diverse paradigms on production-scale graphs with millions of entities.
System
Epoch Time (s)
1-GPU
2-GPU
4-GPU
8-GPU
Marius ( Mohoney et al., 2021 ) *
727
-
-
-
PBG ( Lerer et al., 2019 ) *
3060
1400
515
419
SMORE ( Ren et al., 2022 ) *
760
411
224
121
NGDB-Zoo (Ours)
628
322
181
94
Table 2: Runtime performance on Freebase KG. *Results taken from Mohoney et al. (2021) and Ren et al. (2022) with the same V100 GPUs.
MRR (%)
Training queries (Queries/Sec)
GPU Memory (GB)
Dataset
Model
KGR
SMORE
SQE
NGDB-Zoo
KGR
SMORE
SQE
NGDB-Zoo
KGR
SMORE
SQE
NGDB-Zoo
FB15k
BetaE
41.60
40.39
40.82
43.04
291
2808
636
4477
2.68
1.16
8.05
12.95
Q2B
38.00
41.54
41.08
42.85
855
3588
343
4086
1.32
0.96
6.01
5.07
GQE
28.00
30.60
29.21
30.39
1395
3770
4598
6271
0.76
1.09
8.03
11.33
Q2P
-
-
44.30
46.90
-
-
832
1940
-
-
4.76
11.41
FuzzQE
-
-
42.17
42.33
-
-
720
2973
-
-
20.14
8.45
Table 3: Performance comparison of NGDB-Zoo vs. KGReasoning, SMORE and SQE.
Figure 7: Multi-GPU Throughput Scalability. Training throughput increases near-linearly with the number of GPUs across ogbl-wikikg2 and ATLAS-Wiki-Triple-4M. Units are in # Queries (x1K/sec).
Figure 8: Impact of Decoupled Semantic Integration. We compare the standard joint training (Solid) against our GPU-Resident Decoupled strategy (Hatched //) across three datasets and models. (a) Predictive Performance: Our method consistently improves MRR than without semantic priors by leveraging semantic priors. (b) Throughput: By removing the heavy Text Encoder from the training loop, we achieve a 5x-7x speedup . (c) Memory: Despite caching embeddings, peak memory is reduced because the encoder is unloaded. Note: Higher is better for (a)&(b); lower is better for (c).
Figure 9: Performance comparison with and without Adaptive Sampling. Adaptive Sampling consistently improves MRR over all models and datasets.
Appendix figures & tables5 assets
Supplementary material from the paper’s appendix.
Appendix
Dataset
Entities
Relations
Train Edges
Valid Edges
Test Edges
Total Edges
FB15k
14,951
1,345
483,142
50,000
59,071
592,213
FB15k-237
14,505
237
272,115
17,526
20,438
310,079
NELL995
63,361
200
114,213
14,324
14,267
142,804
FB400k
409,829
918
1,075,837
537,917
537,917
2,151,671
ogbl-wikikg2
2,500,604
535
16,109,182
429,456
598,543
17,137,181
ATLAS-Wiki-Triple-4M
4,035,238
512,064
23,040,868
2,880,108
2,880,110
28,801,086
Appendix
Table 4: KG statistics with number of entities, relations, training, validation and test edges.
Parameter
Value
Batch Size
512 queries
Optimizer
Adam (lr 10−4 )
Margin ( γ )
12.0
Appendix
Table 5: Hyperparameter settings and model configurations.
Operator
Baseline (ms)
Batched (ms)
Speedup
EmbedE
2.3
0.8
2.88×
Project
15.7
4.2
3.74×
Intersect
78.5
6.0
13.11 ×
Union
62.3
5.1
12.22×
Appendix
Table 6: Comparison of execution time per operator: Baseline vs. Batched.
Dataset
Metrics
2in
3in
inp
pin
pni
avg
FB15k
MRR
13.00
14.97
9.17
6.11
11.88
11.03
Hit@10
26.36
30.56
18.53
11.97
23.74
22.23
FB15k-237
MRR
3.96
6.95
6.52
3.97
2.96
4.87
Hit@10
7.75
14.19
13.45
7.45
5.08
9.584
NELL995
MRR
4.06
6.65
8.03
3.25
2.92
4.98
Hit@10
7.84
14.88
16.05
5.61
5.31
9.94
Appendix
Table 7: Performance (%) of BetaE on queries with negation.
MRR (%)
Training queries (Queries/Sec)
GPU Memory (GB)
Dataset
Model
NGDB-Zoo
NGDB-Zoo + Optimizations
NGDB-Zoo
NGDB-Zoo + Optimizations
NGDB-Zoo
NGDB-Zoo + Optimizations
FB15k
BetaE +Qwen-EMB
42.04
46.92
209
1516
14.23
13.11
Q2B +Qwen-EMB
41.85
50.86
348
2014
6.39
5.18
GQE +Qwen-EMB
29.39
35.91
558
2254
12.61
11.49
BetaE +BGE-Base-En-v1.5
42.04
45.37
187
1402
14.40
13.21
Q2B +BGE-Base-En-v1.5
41.85
47.54
340
1886
6.55
5.23
Appendix
Table 8: Performance comparison with and without Semantic Entity Representations optimizations across three datasets (FB15k, FB15k-237, NELL995) and three models (BetaE, Q2B, GQE). Solid bars show baseline performance, hatched bars (//) show optimized performance. Higher is better for MRR and throughput; lower is better for memory. The optimizations consistently improve MRR across all models and datasets, dramatically increase training throughput, and modestly reduce memory consumption.
Graph Neural Networks on large graphs commonly rely on in-memory graph storage with ad hoc data processing pipelines for both training and inference. Graph databases provide scalable storage and efficient traversal for graphs that can evolve over time, but their applicability in GNN training and inference are rarely studied. We show that graph DBs can be used in GNN training and inference directly, executing sampling, feature retrieval, and even the full forward pass. We show different GNN training pipelines can perform on-the-fly sampling and retrieval in graph DBs using Cypher. We further provide optimisations that speed up the training process by ~2.5x while maintaining the same accuracy. We illustrate that fully in-DB inference is possible, independent of how the GNNs are trained. Our inference setup can be >10x faster than cold loading the graph into RAM with no extra memory overhead on real-world graphs. Our work lays the foundation for in-graph-DB GNN training and inference.
Victor Pekkari, Harry Wik, Alfred Clemedtson +2
Lund University, Faculty of Engineering, Lund, Sweden · Neo4j, London, England
Data critical to real-world decision-making is increasingly found within organizations. Such data is heterogeneous, constantly evolving, and only imperfectly captured. However, current data management systems remain largely passive, retrieving what is explicitly stored while offering limited support for uncovering implicit structure or reasoning under noise, incompleteness, and continuous updates. We argue that next-generation data management requires neural capabilities, which can uncover complex latent relationships, distinguish reliable signals from noise, and remain consistent as the underlying data state evolves. To support this direction, we introduce NGDBench, a benchmark across five domains that unifies structured and unstructured sources. NGDBench adopts a graph view because graphs provide a flexible abstraction for modeling complex systems, capturing latent relationships, and subsuming structured formats such as relational tables. Each instance pairs a clean latent graph with a realistically perturbed observed graph. NGDBench supports full Cypher queries and dynamic data management operations. Evaluations of state-of-the-art Text-to-Cypher by LLMs and GraphRAG pipelines reveal that current neural query methods remain sensitive to noise and struggle with dynamic state tracking, highlighting the need for resilient, inference-capable data management. Our code is available at https://github.com/HKUST-KnowComp/NGDBench.
Yufei Li, Yisen Gao, Jiaxuan Xiong +6
HKUST · Beijing Institute of Technology · Hong Kong Baptist University +1
Standard dense retrievers lack a native calculus for multi-atom logical constraints. We introduce Neuro-Symbolic Fuzzy Logic (NSFL), a framework that adapts formal t-norms and t-conorms to neural embedding spaces without requiring retraining. NSFL operates as a first-order hybrid calculus: it anchors logical operations on isolated zero-order similarity scores while actively steering representations using Neuro-Symbolic Deltas (NS-Delta) -- the first-order marginal differences derived from contextual fusion. This preserves pure atomic meaning while capturing domain reliance, preventing the representation collapse and manifold escape endemic to traditional geometric baselines. For scalable real-time retrieval, Spherical Query Optimization (SQO) leverages Riemannian optimization to project these fuzzy formulas into manifold-stable query vectors. Validated across six distinct encoder configurations and two modalities (including zero-shot and SOTA fine-tuned models), NSFL yields mAP improvements up to +81%. Notably, NSFL provides an additive 20% average and up to 47% boost even when applied to encoders explicitly fine-tuned for logical reasoning. By establishing a training-free, order-aware calculus for high-dimensional spaces, this framework lays the foundation for future dynamic scaling and learned manifold logic.