Relational Deep Learning: Learning from Relational Databases using GNNs

Relational Deep Learning (RDL) proposes a unified graph-based way to model multi-table databases for end-to-end learning using GNNs. This retains relational semantics, avoids joins, and supports temporal reasoning. It’s a paradigm shift that bridges the gap between ML and databases.

1. Motivation: From Tables to Graphs

Traditional Setup

Relational databases store structured data across multiple normalized tables, each capturing different types of entities (e.g., users, orders, products). These tables are linked by foreign-key (FK) and primary-key (PK) constraints.

To train machine learning models, these databases are typically flattened into a single table using joins, and domain experts manually select and engineer features.

Problems:

• Joins are expensive and brittle (schema changes break pipelines).

• Manual feature engineering is time-consuming and lacks relational awareness.

• Loss of information about cross-entity relationships.

2. Core Idea: Learn Directly on the Schema

This paper proposes Relational Deep Learning (RDL) — a paradigm where:

• The database is automatically transformed into a graph (called Relational Entity Graph).

• A Graph Neural Network (GNN) learns over this graph end-to-end.

This means:

• No need for manual joins or feature crafting.

• You preserve multi-hop relationships (e.g., customer → transaction → product → vendor).

• Dynamic predictions (e.g., churn, fraud) are enabled using temporal signals.

3. Relational Entity Graph (REG): The Foundation

How it's Built

Given a relational database:

• Nodes = rows in tables (e.g., each customer, order, product is a node).

• Edges = FK–PK links (e.g., order belongs to a customer).

This forms a heterogeneous graph:

• Different node types: customers, products, transactions.

• Different edge types: “purchased”, “reviewed”, etc.

Optional Additions

• Node features: row attributes (e.g., age, price, date).

• Timestamps: used for dynamic/temporal GNNs.

This graph retains relational and structural information that flat feature vectors would discard.

4. Deep Learning Pipeline

Here’s how the full machine learning pipeline works:

(1) Task Definition

• The user defines a training table with the target label(s).

• This table typically links to the entities of interest (e.g., users for churn, transactions for fraud).

(2) Graph Construction

• From the schema + keys, build the REG automatically.

(3) Feature Encoding

• Convert raw database features into tensor representations:

  • Categorical → embeddings

  • Numeric → normalization

  • Timestamp → time-aware features

(4) Message Passing

• Apply GNN layers (e.g., GraphSAGE, GAT) over the graph.

• Each node updates its representation by aggregating messages from neighbors.

• Enables multi-hop reasoning: a user's node learns from the behavior of purchased products, other users, etc.

(5) Prediction

• Add MLP layers for classification/regression depending on the task.

• Backpropagation updates all weights across message passing and embeddings.

5. Related Concepts AI Engineers Should Know

A. Relational Databases

• Normalization: reduces redundancy; leads to many tables.

• Foreign keys: links from one table to a related row in another.

• Joins: SQL operations to combine data from multiple tables.

Ref:

• Database System Concepts (Silberschatz et al.)

B. Graph Neural Networks

• Message-passing networks update each node's state by aggregating info from neighbors.

• Key architectures:

  • GCN (Kipf & Welling): basic spectral approach

  • GraphSAGE: learns aggregators from neighborhood

  • GAT: uses attention over neighbors

Ref:

• Battaglia et al. “Relational inductive biases...” (2018)

• Wu et al. “Comprehensive Survey on GNNs” (2020)

C. Temporal Graph Learning

• Tasks where the time of interactions matters.

• GNNs with time-aware components (e.g., TGAT, TGN) are used for:

  • Dynamic recommendation

  • Fraud detection

  • Churn prediction

Ref:

• Rossi et al. “Temporal Graph Learning” (2020)

6. Benchmarks and Tools

The authors introduce RelBench, a benchmark suite of relational datasets + predictive tasks, including:

• Stack Exchange QA threads

• Amazon product reviews

• Online retailers and clickstreams

They also provide:

• Data conversion tools from SQL → REG graph

• GNN training pipelines using PyTorch Geometric

References

• Paper: arXiv:2312.04615

• Authors: Matthias Fey et al.

• Code: https://github.com/snap-research/RelationalDeepLearning

• Benchmark: RelBench