GNN, Transformers en RL voor arbitrage: wanneer neurale netwerken leren traden

Deel 5 van de serie "Complexe arbitrageketens tussen futures en spot"

Stel je een schaakgrootmeester voor die, in plaats van een bord, tien exchanges ziet met honderden handelsparen, en in plaats van 32 stukken duizenden orders ziet die elke milliseconde worden bijgewerkt. Klassieke algoritmes zoals Bellman-Ford doorlopen de graaf eerlijk, maar tegen de tijd dat ze een winstgevende cyclus vinden, is het venster van kans al gesloten. We hebben een andere aanpak nodig—niet alleen algoritmisch, maar geleerd.

In dit artikel onderzoeken we hoe moderne ML-methoden de chaotische multi-exchangemarkt omzetten in een gestructureerde taak. Graph Neural Networks (GNN's), Transformers en Reinforcement Learning-agenten (RL) herdefiniëren wat mogelijk is in de wereld van arbitrage.

Overzicht van ML-benaderingen voor arbitragedetectie en -uitvoering: van graph neural networks tot evolutionaire algoritmes.

1. Graph Neural Networks: wanneer de markt een graaf is

De multi-exchange cryptomarkt is van nature een graaf. Nodes zijn assets (BTC, ETH, SOL) of "asset-exchange"-paren. Edges zijn handelsverbindingen, gewogen naar spreads, volumes, kosten en latenties.

Het klassieke Bellman-Ford lost de taak op in $O(V \times E)$. Graph Neural Networks (GNN) leren patronen te herkennen die voorafgaan aan arbitragemogelijkheden, vergelijkbaar met de "intuïtie" van een taxichauffeur voor waar een file zal ontstaan.

1.1 GraphSAGE met Edge Fusion

Met GraphSAGE en een aangepaste edge-fusiemodule bereikten onderzoekers:

• F1-score: 0,90—9 van de 10 voorspelde kansen zijn echt.
• Inferentie: 78 ms op CPU—snel genoeg voor veel arbitragevensters.

use burn::prelude::*;
use burn::nn::{Linear, LinearConfig, Relu};

#[derive(Module, Debug)]
pub struct EdgeFusionModule<B: Backend> {
    fc1: Linear<B>,
    fc2: Linear<B>,
    fc_out: Linear<B>,
    relu: Relu,
}

2. Transformers: Attention is All You Need

Waar GNN's werken met de structuur van de markt, werken Transformers met datastromen. Multi-head self-attention legt afhankelijkheden tussen assets en exchanges vast zonder expliciet te hoeven definiëren wie wie beïnvloedt.

2.1 Multi-head attention voor multi-exchange fusie

De gewichten van het attentiemechanisme laten zien welke exchanges het meest informatief zijn voor het voorspellen van de prijs op de doelexchange. Een plotselinge stijging van het attentiegewicht tussen twee exchanges is vaak een signaal van een naderende arbitragemogelijkheid.

3. Reinforcement Learning: de agent die leert traden

Reinforcement Learning (RL) past van nature bij het arbitrageprobleem. De state bestaat uit orderboeken, posities en saldi. De action is wat je waar en in welk volume verhandelt. De reward is de winst of het verlies.

3.1 142% jaarlijks rendement

Het meest indrukwekkende resultaat is Multi-Agent RL voor competitieve arbitrage op DEX's. Door gespecialiseerde agenten (CEX-DEX, cross-chain en triangulair) te coördineren, behaalden onderzoekers 142% jaarlijks rendement tegenover 12% voor regelgebaseerde bots.

4. Bayesiaanse methoden: onzekerheid als voordeel

Bayesian Online Changepoint Detection (BOCPD) detecteert regimeveranderingen in real-time. Wanneer de "regels" van de markt veranderen, herkent het model dit en vertelt het de strategie om te pauzeren en opnieuw te kalibreren.

/// Regime change detector based on BOCPD
pub struct BocpdDetector {
    lambda: f64,                         // P(changepoint) = 1/lambda
    run_length_probs: Vec<f64>,          // run length distribution
}

5. Geïntegreerde architectuur: alles samenbrengen

Ware kracht komt voort uit integratie. Een geïntegreerde pipeline in Rust ziet er als volgt uit:

1. Feature engineering: orderboekkenmerken, spreads, CUSUM/EWMA-monitoring.
2. Detectie: GNN's en autoencoders vinden anomalieën.
3. Signaalfusie: Transformers combineren cross-exchange- en spot-futuresdata.
4. Uitvoering: RL-agenten bepalen de optimale omvang en timing.
5. Risico: Bayesiaanse sizing en Gaussian Process-grenzen.

Totaal latentiebudget: met Rust en ONNX Runtime is een totale pipeline-latentie van < 7,5 ms haalbaar.

6. Conclusie

ML in arbitrage is geen wondermiddel, maar een arsenaal aan tools. GNN's zien de structuur, Transformers combineren de data, RL voert uit, en Bayesiaanse methoden beheren de onzekerheid.

In het laatste deel van deze serie bekijken we de details van de Rust-implementatie van zo'n systeem, met de focus op nanoseconde-precisie en atomaire multi-leg-uitvoering.

Train je je eigen agenten? Bekijk ons Rust ML Trading Framework op GitHub.