Technische Samenvatting: Integratie van Deep Learning-ontwerp in Databasequeries

Probleemstelling

De integratie van deep learning (DL) en relationele databases is traditioneel gehinderd door een "round-trip" engineering- overhead. Conventionele benaderingen vereisen het vertalen van relationele data naar grafrepresentaties (waarbij records knopen worden en vreemde sleutels randen) en vervolgens het exporteren van deze data naar externe machine learning-frameworks (bijv. PyTorch Geometric, DGL) om Graph Neural Networks (GNN's) te trainen. Dit proces dwingt ontwikkelaars om te werken binnen uiteenlopende paradigma's: het gebruik van declaratieve querytalen voor datamanagement en imperatieve code voor modelontwerp. Bovendien sluiten bestaande ML-frameworks binnen de database deze domeinen vaak aan door tensor-types en lineair-algebra-operatoren direct in de query-engine te integreren, waarbij gebruikers expliciet de verbinding tussen logische data en vectorrepresentaties moeten onderhouden. De auteurs betogen dat deze scheiding kunstmatig is en dat het specificeren van een neurale netwerk over relationele data even natuurlijk moet zijn als het queryen van de data zelf.

Methodologie: Neuro-Relationele Algebra (NRA) en RelaNN

Het artikel stelt RelaNN voor, een proof-of-concept systeem dat deep learning direct integreert in databasequeries door het relationele model uit te breiden. De kernmethodologie rust op Neuro-Relationele Algebra (NRA), een formeel raamwerk dat elke database-tuple koppelt aan een leerbare vector-embedding.

1. Neuro-Relationeel Data Model (NRM)

Het data-model breidt het klassieke relationele model uit door een geëmbedeerde relatie $(r, \eta)$ te definiëren, waarbij $r$ de standaard inhoudsrelatie is en $\eta$ een annotatie die elke tuple afbeeldt op een embedding in $\mathbb{R}^d$. Dit stelt het systeem in staat om gelijktijdig te opereren op het logische domein (inhoud) en het numerieke domein (embeddings).

2. Neuro-Relationele Operatoren

NRA breidt de standaard relationele algebra uit met operatoren die zowel inhoud als embeddings manipuleren:

• Join ($\bowtie$): Voert een standaard natuurlijke join uit op inhoud. Voor embeddings concateneert het de embeddings van de bijdragende tuples uit de invoerrelaties.
• Geprojecteerde Unie ($\cup_{\alpha, A}$): Een geünificeerde operator die projectie en unie combineert. Het projecteert tuples op een gemeenschappelijke attribuutsequentie en aggregeert de embeddings van tuples met identieke inhoud met behulp van een multiset-aggregator $\alpha$ (bijv. som, gemiddelde, maximum). Dit behandelt de aggregatie van embeddings die vereist is wanneer meerdere invoertuples naar dezelfde output-tuple mappen.
• Transformatie ($T_\tau$): Past een differentieerbare transformatie $\tau$ (bijv. een feed-forward netwerk, ReLU of lineaire laag) toe op de embeddings van een relatie. Dit is het primaire mechanisme voor het introduceren van leerbare parameters.
• Selectie, Verschil, Hernoemen: Deze operatoren laten embeddings onveranderd passeren, vergelijkbaar met klassieke algebra.

3. De RelaNN-taal

RelaNN is een declaratieve taal gebouwd bovenop NRA. Programma's bestaan uit regelstatements die definiëren hoe nieuwe geëmbedeerde relaties worden afgeleid:

• Join-regels: Combineren relaties via joins, passen een transformatie toe op de geconcateneerde embeddings en aggregeren via een geprojecteerde unie.
• Unieregels: Unificeren relaties met identieke schema's, filteren en transformeren embeddings.
• Fit-statement: Een taalconstruct (?fit) dat een verliesfunctie minimaliseert die is gedefinieerd over een outputrelatie, en de globale parameter-toewijzing bijwerkt (inclusief zowel tuple-embeddings als transformatiegewichten).
• Predict-statement: Evalueert het programma met huidige parameters om resultaten te materialiseren.
• Extensies: De taal ondersteunt aliassen voor parameterdeling, functiedefinities voor codehergebruik, codering/decodering om data te verplaatsen tussen inhoudskolommen en embeddings, en sjablonen om repetitieve regels te genereren (bijv. voor multi-head attention).

4. Implementatiepijplijn

RelaNN compileert een programma naar een Term Graph (een DAG van NRA-operatoren). Bij uitvoering wordt deze graf vertaald naar een Fysiek Plan dat draait over SQL, cuDF en PyTorch:

• Data Laden: SQL-query's halen inhoud op uit de database.
• Join/Selectie: Geïmplementeerd via cuDF DataFrame-operaties (merge, index_select) die rij-index-tensors uitschrijven.
• Embedding Manipulatie: PyTorch-operaties (bijv. torch.index_select, scatter_add) halen en aggregeren embeddings op basis van de inhoudsindexen, waarbij volledige differentieerbaarheid voor end-to-end training wordt behouden.
• Transformatie: Aangepaste nn.Module-lagen worden direct via PyTorch toegepast.

Belangrijkste Bijdragen

1. Formeel Raamwerk (NRA): De introductie van Neuro-Relationele Algebra, die relationele queryverwerking en neuraal modelontwerp verenigt door het relationele model uit te breiden met leerbare tuple-embeddings.
2. Declaratief Systeem (RelaNN): Een open-source systeem dat gebruikers in staat stelt state-of-the-art graf-leerarchitecturen te implementeren met vertrouwde SQL/Datalog-achtige constructies.
3. Expressiviteit: Aangetoond vermogen om complexe architecturen uit te drukken, waaronder Graph Convolutional Networks (GCN), Relational GCN (R-GCN), Heterogeneous Graph Transformers (HGT), Hypergraph Neural Networks (HyGNN) en Deep Homomorphism Networks (DHN), met aanzienlijk minder regels code dan imperatieve baselines.
4. Prestaties: Een proof-of-concept implementatie die concurrerende voorspellende nauwkeurigheid en runtime-prestaties bereikt in vergelijking met gespecialiseerde bibliotheken zoals PyTorch Geometric.

Experimentele Resultaten

De auteurs evalueerden RelaNN tegen referentie-implementaties (PyTorch, PyG) op vijf architecturen over meerdere datasets (Cora, DBLP, AIFB, CSL, EXP, DrugBank, enz.).

• Codeconcisie: RelaNN-programma's waren ongeveer 4x korter dan baseline-implementaties. Bijvoorbeeld, een implementatie van een Deep Homomorphism Network (DHN) vereiste 76 regels in RelaNN versus 259 regels in de baseline.
• Nauwkeurigheid: RelaNN reproduceerde de referentienauwkeurigheid voor GCN en HGT. Voor andere modellen (R-GCN, HyGNN, DHN) lagen de resultaten binnen één standaardafwijking van baselines of kwamen ze exact overeen (bijv. 100% nauwkeurigheid op de CSL-dataset voor DHN).
• Runtime:
  • Voor GCN en HGT lag de RelaNN-runtime binnen een factor 2 van de baseline.
  • Voor DHN was RelaNN 2x tot 14x sneller dan de baseline, toegeschreven aan de efficiëntie van de declaratieve compilatie en het vermijden van complexe aangepaste tensorcode.
  • Voor R-GCN op de AIFB-dataset was RelaNN ongeveer 30x trager dan de sterk geoptimaliseerde torch-rgcn-baseline. De auteurs schrijven dit toe aan het feit dat de huidige implementatie een niet-geoptimaliseerde proof-of-concept is en aan het gespecialiseerde karakter van de baseline.

Betekenis en Claims

Het artikel claimt dat RelaNN een declaratieve basis biedt voor relationeel deep learning, en aantoont dat het mogelijk is state-of-the-art neurale netwerken direct over relationele databases te ontwerpen en te trainen zonder tussenliggende grafrepresentaties.

• Simpliciteit: Het systeem maakt het implementeren van complexe architecturen zo eenvoudig als het schrijven van een query, waardoor de engineering-overhead van datatranslatie en grafconstructie wordt verwijderd.
• Integratie: Door embeddings als first-class burgers binnen het relationele model te behandelen, voegt deze aanpak logisch redeneren op natuurlijke wijze samen met numeriek redeneren.
• Toekomstpotentieel: Hoewel de huidige implementatie een prototype is, betogen de auteurs dat het een "concrete weg" vertegenwoordigt om deep learning over databases even toegankelijk te maken als standaard queryen. Zij identificeren toekomstig werk in het schalen naar datasets groter dan GPU-geheugen (via sampling en streaming) en het optimaliseren van query-uitvoering (transformaties push-down, kernen fuseren) om de prestatiekloof met gespecialiseerde bibliotheken te dichten.

De auteurs stellen expliciet dat hun werk niet claimt enterprise-systemen te vervangen, maar eerder de haalbaarheid en simpliciteit van een geünificeerde aanpak demonstreert, de weg effenend voor toekomstige optimalisaties en de potentiële implementatie van relationele foundation-modellen.