Een uitgebreide introductie tot Graph Neural Networks (GNN’s)

Wat is een graaf (Graph)?

Een graaf is een datastructuur met knopen en randen. Een knoop kan een persoon, plaats of ding zijn, en de randen definiëren de relatie tussen knopen. De randen kunnen gericht of ongericht zijn, afhankelijk van directionele afhankelijkheden. 

In het voorbeeld hieronder zijn de blauwe cirkels knopen en de pijlen randen. De richting van de randen definieert afhankelijkheden tussen twee knopen. 

Afbeelding door de auteur 

Laten we leren over de complexe graafdataset: Jazz Musicians Network. Deze bevat 198 knopen en 2742 randen. In de community-graafplot hieronder vertegenwoordigen de verschillende kleuren van knopen diverse gemeenschappen van jazzmuzikanten en de randen die hen verbinden. Er is een web van samenwerking waarbij één muzikant relaties heeft binnen en buiten de gemeenschap. 

 Community-graafplot door Jazz Musicians Network

Grafen zijn uitstekend geschikt voor complexe problemen met relaties en interacties. Ze worden gebruikt in patroonherkenning, analyse van sociale netwerken, aanbevelingssystemen en semantische analyse. Het bouwen van graafgebaseerde oplossingen is een heel nieuw vakgebied dat rijke inzichten biedt in complexe en onderling verbonden datasets.

Grafen met NetworkX

In deze sectie leren we een graaf te maken met NetworkX. 

De onderstaande code is geïnspireerd op Daniel Holmbergs blog over Graph Neural Networks in Python.

1. Maak een DiGraph-object “H” van networkx
2. Voeg knopen toe met verschillende labels, kleuren en groottes
3. Voeg randen toe om een relatie tussen twee knopen te creëren. Bijvoorbeeld, “(0,1)” betekent dat 0 een directionele afhankelijkheid heeft van 1. We creëren bidirectionele relaties door “(1,0)” toe te voegen
4. Haal kleuren en groottes op in de vorm van lijsten
5. Plot de graaf met de draw-functie van networkx

import networkx as nx
H = nx.DiGraph()

#adding nodes
H.add_nodes_from([
  (0, {"color": "blue", "size": 250}),

  (1, {"color": "yellow", "size": 400}),

  (2, {"color": "orange", "size": 150}),

  (3, {"color": "red", "size": 600})


])

#adding edges
H.add_edges_from([
  (0, 1),

  (1, 2),

  (1, 0),

  (1, 3),

  (2, 3),

  (3,0)


])

node_colors = nx.get_node_attributes(H, "color").values()
colors = list(node_colors)
node_sizes = nx.get_node_attributes(H, "size").values()
sizes = list(node_sizes)

#Plotting Graph
nx.draw(H, with_labels=True, node_color=colors, node_size=sizes)

In de volgende stap zetten we de datastructuur om van een gerichte naar een ongerichte graaf met de functie to_undirected(). 

#converting to undirected graph
G = H.to_undirected()
nx.draw(G, with_labels=True, node_color=colors, node_size=sizes)

Waarom is een graaf analyseren lastig?

Graafgebaseerde datastructuren hebben beperkingen, en data scientists moeten die begrijpen voordat ze graafgebaseerde oplossingen ontwikkelen.

1. Een graaf bestaat in niet-euclidische ruimte. Hij bestaat niet in 2D- of 3D-ruimte, wat het moeilijker maakt om de data te interpreteren. Om de structuur in 2D te visualiseren, moet je verschillende dimensionaliteitsreductietools gebruiken.
2. Grafen zijn dynamisch; ze hebben geen vaste vorm. Er kunnen twee visueel verschillende grafen zijn die toch vergelijkbare adjacency-matrixrepresentaties hebben. Dat maakt het lastig om data te analyseren met traditionele statistische tools. 
3. Grote omvang en dimensionaliteit vergroten de complexiteit van de graaf voor menselijke interpretatie. De dichte structuur met meerdere knopen en duizenden randen is moeilijker te begrijpen en er inzichten uit te halen. 

Wat is een Graph Neural Network (GNN)?

Graph Neural Networks zijn speciale neurale netwerken die overweg kunnen met een graafdatastructuur. Ze zijn sterk beïnvloed door Convolutional Neural Networks (CNN’s) en graaf-embedding. GNN’s worden gebruikt voor het voorspellen van knopen, randen en graafgebaseerde taken. 

• CNN’s worden gebruikt voor beeldclassificatie. Op vergelijkbare wijze worden GNN’s toegepast op graafstructuren (raster van pixels) om een klasse te voorspellen. 
• Recurrente neurale netwerken worden gebruikt bij tekstclassificatie. Evenzo worden GNN’s toegepast op graafstructuren waarbij elk woord een knoop in een zin is.  

GNN’s werden geïntroduceerd toen Convolutional Neural Networks geen optimale resultaten behaalden door de willekeurige grootte van de graaf en de complexe structuur. 

Afbeelding door Purvanshi Mehta

De invoergraaf wordt door een reeks neurale netwerken geleid. De invoergraafstructuur wordt omgezet in een graaf-embedding, zodat we informatie over knopen, randen en globale context behouden. 

Vervolgens wordt de featurevector van de knopen A en C door de neurale netwerklaag gehaald. Deze layer aggregeert deze features en geeft ze door aan de volgende laag - neptune.ai.

Lees onze tutorial Deep Learning of volg onze cursus Introduction to Deep Learning om meer te leren over deep learning-algoritmen en -toepassingen. 

Typen Graph Neural Networks

Er zijn verschillende typen neurale netwerken en de meeste hebben een variant op Convolutional Neural Networks. In deze sectie leren we over de populairste GNN’s. 

• Graph Convolutional Networks (GCN’s) lijken op traditionele CNN’s. Ze leren features door naburige knopen te inspecteren. GNN’s aggregeren knoopvectoren, geven het resultaat door aan de dense laag en passen niet-lineariteit toe via de activatiefunctie. Kort gezegd bestaan ze uit graafconvolutie, een lineaire laag en een niet-lineaire activatiefunctie. Er zijn twee hoofdtypen GCN’s: Spatial Convolutional Networks en Spectral Convolutional Networks.
• Graph Auto-Encoder Networks leren graafrepresentaties met een encoder en proberen de invoergrafen te reconstrueren met een decoder. De encoder en decoder worden verbonden door een bottlenecklaag. Ze worden vaak gebruikt bij linkvoorspelling, omdat auto-encoders goed omgaan met klassenbalans. 
• Recurrent Graph Neural Networks (RGNN’s) leren het beste diffusiepatroon en kunnen multi-relationele grafen aan waar één knoop meerdere relaties heeft. Dit type graafneuraal netwerk gebruikt regularizers om de gladheid te vergroten en over-parameterisatie te voorkomen. RGNN’s gebruiken minder rekenkracht om betere resultaten te produceren. Ze worden gebruikt voor tekstopwekking, machinevertaling, spraakherkenning, het genereren van beeldbeschrijvingen, videotagging en tekstsamenvatting.
• Gated Graph Neural Networks (GGNN’s) presteren beter dan RGNN’s bij taken met langetermijnafhankelijkheden. Gated Graph Neural Networks verbeteren Recurrent Graph Neural Networks door knoop-, rand- en tijd-“gates” toe te voegen voor langetermijnafhankelijkheden. Net als bij Gated Recurrent Units (GRU’s) worden gates gebruikt om informatie in verschillende toestanden te onthouden en te vergeten. 

Als je meer wilt leren over Recurrent Neural Networks (RNN’s), bekijk dan de cursus van DataCamp. Die introduceert je in verschillende RNN-architecturen, Keras-frameworks en RNN-toepassingen. 

Typen taken voor Graph Neural Networks

Hieronder hebben we enkele typen GNN-taken met voorbeelden op een rij gezet:

• Graafclassificatie: we gebruiken dit om grafen in verschillende categorieën te classificeren. Toepassingen zijn onder andere analyse van sociale netwerken en tekstclassificatie. 
• Knoopclassificatie: deze taak gebruikt labels van naburige knopen om ontbrekende knooplabels in een graaf te voorspellen. 
• Linkvoorspelling: voorspelt de link tussen een paar knopen in een graaf met een onvolledige adjacency-matrix. Dit wordt vaak gebruikt voor sociale netwerken. 
• Communitydetectie: verdeelt knopen in verschillende clusters op basis van de randstructuur. Het leert op vergelijkbare wijze van randgewichten, afstand en graafobjecten. 
• Graaf-embedding: zet grafen om naar vectoren, waarbij relevante informatie over knopen, randen en structuur behouden blijft.
• Graafgeneratie: leert van voorbeelddistributies van grafen om een nieuwe maar vergelijkbare graafstructuur te genereren. 

Afbeelding door de auteur

Nadelen van Graph Neural Networks

Er zijn enkele nadelen aan het gebruik van GNN’s. Als we die begrijpen, kunnen we bepalen wanneer we GNN’s gebruiken en hoe we de prestaties van onze machine learning-modellen optimaliseren. 

1. De meeste neurale netwerken kunnen diep gaan voor betere prestaties, terwijl GNN’s ondiepe netwerken zijn met meestal drie lagen. Dat beperkt ons in het behalen van state-of-the-art prestaties op grote datasets.
2. De graafstructuren veranderen voortdurend, wat het lastiger maakt om er een model op te trainen. 
3. Het uitrollen van het model naar productie stuit op schaalbaarheidsproblemen, omdat deze netwerken rekenintensief zijn. Als je een grote en complexe graafstructuur hebt, wordt het moeilijk om GNN’s in productie op te schalen. 

Wat is een Graph Convolutional Network (GCN)?

Het merendeel van de GNN’s zijn Graph Convolutional Networks, en het is belangrijk om daarover te leren voordat we in een tutorial over knoopclassificatie duiken.  

De convolutie in GCN is dezelfde als de convolutie in convolutionele neurale netwerken. Hij vermenigvuldigt neuronen met gewichten (filters) om van datafeatures te leren. 

Hij werkt als schuivende vensters over hele afbeeldingen om features te leren uit naburige cellen. Het filter gebruikt weight sharing om verschillende gelaatskenmerken te leren in beeldherkenningssystemen - Towards Data Science. 

Breng nu dezelfde functionaliteit over naar Graph Convolutional Networks, waar een model features leert uit naburige knopen. Het belangrijkste verschil tussen GCN en CNN is dat GCN’s zijn ontwikkeld om te werken op niet-euclidische datastructuren, waar de volgorde van knopen en randen kan variëren. 

CNN vs GCN | Afbeelding bron

Leer meer over basis-CNN’s met de tutorial Convolutional Neural Networks (CNN) met TensorFlow. 

Er zijn twee typen GCN’s: 

• Spatial Graph Convolutional Networks gebruiken ruimtelijke kenmerken om te leren van grafen die zijn gepositioneerd in de ruimtelijke ruimte.  
• Spectral Graph Convolutional Networks gebruiken eigendecompositie van de graaf-Laplaciaanmatrix voor informatiepropagatie langs knopen. Deze netwerken zijn geïnspireerd op golfpropagatie in signalen en systemen. 

Hoe werken GNN’s? Een Graph Neural Network bouwen met Pytorch

We bouwen en trainen een Spectral Graph Convolution voor een knoopclassificatiemodel. De broncode is beschikbaar in deze DataLab-workbook zodat je je eerste graafgebaseerde machine learning-model kunt ervaren en draaien. 

De codevoorbeelden zijn geïnspireerd op de documentatie van Pytorch Geometric. 

Aan de slag

We installeren het pakket Pytorch, omdat pytorch_geometric daarop is gebouwd. 

!pip install -q torch

Vervolgens gebruiken we de torch-versie om torch-scatter en torch-sparse te installeren. Daarna installeren we de nieuwste release van pytorch_geometric vanaf GitHub. 

%%capture
import os
import torch
os.environ['TORCH'] = torch.__version__
os.environ['PYTHONWARNINGS'] = "ignore"
!pip install torch-scatter -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install torch-sparse -f https://data.pyg.org/whl/torch-${TORCH}.html
!pip install git+https://github.com/pyg-team/pytorch_geometric.git

Planetoid Cora-dataset

Planetoid is een citatienetwerkdataset afkomstig van Cora, CiteSeer en PubMed. De knopen zijn documenten met 1433-dimensionale bag-of-words-featurevectoren en de randen zijn citatielinks tussen onderzoeksartikelen. Er zijn 7 klassen en we trainen het model om ontbrekende labels te voorspellen. 

We laden de Planetoid Cora-dataset in en rij-normaliseren de bag-of-words-invoerfeatures. Daarna analyseren we de dataset en het eerste graafobject. 

from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures

dataset = Planetoid(root='data/Planetoid', name='Cora', transform=NormalizeFeatures())

print(f'Dataset: {dataset}:')
print('======================')
print(f'Number of graphs: {len(dataset)}')
print(f'Number of features: {dataset.num_features}')
print(f'Number of classes: {dataset.num_classes}')

data = dataset[0]  # Get the first graph object.
print(data)

De Cora-dataset heeft 2708 knopen, 10.556 randen, 1433 features en 7 klassen. Het eerste object heeft 2708 train-, validatie- en testmaskers. We gebruiken deze maskers om het model te trainen en te evalueren. 

Dataset: Cora():
======================
Number of graphs: 1
Number of features: 1433
Number of classes: 7
Data(x=[2708, 1433], edge_index=[2, 10556], y=[2708], train_mask=[2708], val_mask=[2708], test_mask=[2708])

Knoopclassificatie met GNN

We maken een GCN-modelstructuur met twee GCNConv-lagen, relu-activatie en een dropout-ratio van 0,5. Het model bestaat uit 16 verborgen kanalen.  

GCN-laag:

De W(ℓ+1) is een trainbare gewichtsmatrix in de bovenstaande vergelijking en Cw,v duidt op een vaste normalisatiecoëfficiënt voor elke rand.

from torch_geometric.nn import GCNConv
import torch.nn.functional as F

class GCN(torch.nn.Module):
    def __init__(self, hidden_channels):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GCNConv(dataset.num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, dataset.num_classes)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index)
        x = x.relu()
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GCN(hidden_channels=16)
print(model)

>>> GCN(
    (conv1): GCNConv(1433, 16)
    (conv2): GCNConv(16, 7)
  )

Ongetraind GCN-netwerk visualiseren

Laten we knoop-embeddings van ongetrainde GCN-netwerken visualiseren met sklearn.manifold.TSNE en matplotlib.pyplot. Dit plot een 7-dimensionale knoop-embedding in een 2D scatterplot.  

%matplotlib inline
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

def visualize(h, color):
    z = TSNE(n_components=2).fit_transform(h.detach().cpu().numpy())

    plt.figure(figsize=(10,10))
    plt.xticks([])
    plt.yticks([])

    plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap="Set2")
    plt.show()

We evalueren het model en voegen vervolgens trainingsdata toe aan het ongetrainde model om verschillende knopen en categorieën te visualiseren. 

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

GNN trainen

We trainen ons model 100 epochs met Adam-optimalisatie en de Cross-Entropy Loss-functie. 

In de train-functie doen we het volgende:

1. De gradient wissen
2. Eén forward pass uitvoeren
3. De loss berekenen met trainingsknopen
4. De gradient berekenen en de parameters updaten

In de test-functie doen we het volgende:

1. Knoopklassen voorspellen
2. Het klasselabel met de hoogste waarschijnlijkheid extraheren
3. Controleren hoeveel waarden correct zijn voorspeld
4. De nauwkeurigheidsratio maken door het aantal juiste voorspellingen te delen door het totale aantal knopen. 

model = GCN(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test():
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      test_correct = pred[data.test_mask] == data.y[data.test_mask]
      test_acc = int(test_correct.sum()) / int(data.test_mask.sum())
      return test_acc


for epoch in range(1, 101):
    loss = train()
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
GAT(
  (conv1): GATConv(1433, 8, heads=8)
  (conv2): GATConv(64, 7, heads=8)
)

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 0.5989
Epoch: 099, Loss: 0.6021
Epoch: 100, Loss: 0.5799

Model­evaluatie

We evalueren nu het model op een ongeziene dataset met de test-functie en zoals je ziet, hebben we een prima resultaat van 81,5% nauwkeurigheid.  

test_acc = test()
print(f'Test Accuracy: {test_acc:.4f}')


>>> Test Accuracy: 0.8150

We visualiseren nu de output-embedding van een getraind model om de resultaten te verifiëren.

model.eval()
out = model(data.x, data.edge_index)
visualize(out, color=data.y)

Zoals we zien, heeft het getrainde model een betere clustering van knopen perzelfde categorie opgeleverd.

GATConv-model trainen

In de tweede stap vervangen we GCNConv door GATConv-lagen. De Graph Attention Networks gebruiken gemaskeerde self-attentional-lagen om de nadelen van GCNConv aan te pakken en state-of-the-art resultaten te behalen. 

Je kunt ook andere GNN-lagen proberen en spelen met optimalisaties, dropouts en het aantal verborgen kanalen om betere prestaties te bereiken. 

In de onderstaande code hebben we simpelweg GCNConv vervangen door GATConv met 8 attention heads in de eerste laag en 1 in de tweede laag. 

We stellen ook in:

• dropout-ratio op 0,6
• verborgen kanalen op 8
• learning rate op 0,005

We hebben de test-functie aangepast om de nauwkeurigheid van een specifiek masker (validatie, test) te bepalen. Dat helpt ons validatie- en testscores tijdens het trainen te printen. We slaan validatie- en testresultaten ook op om later een lijngrafiek te plotten. 

from torch_geometric.nn import GATConv

class GAT(torch.nn.Module):
    def __init__(self, hidden_channels, heads):
        super().__init__()
        torch.manual_seed(1234567)
        self.conv1 = GATConv(dataset.num_features, hidden_channels,heads)
        self.conv2 = GATConv(heads*hidden_channels, dataset.num_classes,heads)

    def forward(self, x, edge_index):
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv1(x, edge_index)
        x = F.elu(x)
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv2(x, edge_index)
        return x

model = GAT(hidden_channels=8, heads=8)
print(model)

optimizer = torch.optim.Adam(model.parameters(), lr=0.005, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()

def train():
      model.train()
      optimizer.zero_grad()
      out = model(data.x, data.edge_index)
      loss = criterion(out[data.train_mask], data.y[data.train_mask])
      loss.backward()
      optimizer.step()
      return loss

def test(mask):
      model.eval()
      out = model(data.x, data.edge_index)
      pred = out.argmax(dim=1)
      correct = pred[mask] == data.y[mask]
      acc = int(correct.sum()) / int(mask.sum())
      return acc

val_acc_all = []
test_acc_all = []

for epoch in range(1, 101):
    loss = train()
    val_acc = test(data.val_mask)
    test_acc = test(data.test_mask)
    val_acc_all.append(val_acc)
    test_acc_all.append(test_acc)
    print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}, Val: {val_acc:.4f}, Test: {test_acc:.4f}')

.. .. .. ..
.. .. .. ..
Epoch: 098, Loss: 1.1283, Val: 0.7960, Test: 0.8030

Epoch: 099, Loss: 1.1352, Val: 0.7940, Test: 0.8050

Epoch: 100, Loss: 1.1053, Val: 0.7960, Test: 0.8040

Zoals we zien, presteerde ons model niet beter dan GCNConv. Het vereist hyperparameteroptimalisatie of meer epochs om state-of-the-art resultaten te behalen. 

Model­evaluatie

In het evaluatiedeel visualiseren we validatie- en testingscores met een lijngrafiek van matplotlib.pyplot.  

import numpy as np

plt.figure(figsize=(12,8))
plt.plot(np.arange(1, len(val_acc_all) + 1), val_acc_all, label='Validation accuracy', c='blue')
plt.plot(np.arange(1, len(test_acc_all) + 1), test_acc_all, label='Testing accuracy', c='red')
plt.xlabel('Epochs')
plt.ylabel('Accurarcy')
plt.title('GATConv')
plt.legend(loc='lower right', fontsize='x-large')
plt.savefig('gat_loss.png')
plt.show()

Na 60 epochs hebben de validatie- en testnauwkeurigheid een stabiele waarde van 0,8 +/- 0,02 bereikt. 

Laten we opnieuw de knoopclustering van het GATConv-model visualiseren.

model.eval()

out = model(data.x, data.edge_index)
visualize(out, color=data.y)

Zoals we zien, heeft de GATConv-laag vergelijkbare resultaten opgeleverd in de clustering binnen dezelfde categorie knopen. 

We kunnen overfitting verminderen door een tweede validatiedataset toe te voegen en de modelprestaties verbeteren door te experimenteren met verschillende GCN-lagen uit pytoch_geometric. 

De broncode van de tutorial is beschikbaar in deze DataLab-workbook. Maak een kopie van de workbook die je kunt uitvoeren.

Voeg de vaardigheid Deep Learning toe aan je cv door de skill track Deep Learning in Python te volgen. Je maakt kennis met deep learning-algoritmen, Keras, Pytorch en het TensorFlow-framework.