Une introduction complète aux réseaux neuronaux graphiques (GNN)

Qu'est-ce qu'un graphique ?

Un graphique est le type de structure de données qui contient des nœuds et des arêtes. Un nœud peut être une personne, un lieu ou une chose, et les arêtes définissent la relation entre les nœuds. Les arêtes peuvent être dirigées et non dirigées en fonction des dépendances directionnelles. 

Dans l'exemple ci-dessous, les cercles bleus sont des nœuds et les flèches sont des arêtes. La direction des arêtes définit les dépendances entre deux nœuds. 

Image par l'auteur 

Découvrons l'ensemble de données Graphique complexe : Jazz Musicians Network. Il contient 198 nœuds et 2742 arêtes. Dans le graphique communautaire ci-dessous, les différentes couleurs de nœuds représentent les diverses communautés de musiciens de jazz et les arêtes qui les relient. Il existe un réseau de collaboration où un seul musicien entretient des relations à l'intérieur et à l'extérieur de la communauté. 

 Graphique de la communauté par le Réseau des musiciens de jazz

Les graphiques sont excellents pour traiter des problèmes complexes avec des relations et des interactions. Ils sont utilisés dans la reconnaissance des formes, l'analyse des réseaux sociaux, les systèmes de recommandation et l'analyse sémantique. La création de solutions basées sur les graphes est un tout nouveau domaine qui permet d'obtenir de riches informations sur des ensembles de données complexes et interconnectés.

Graphiques avec NetworkX

Dans cette section, nous allons apprendre à créer un graphique à l'aide de NetworkX. 

Le code ci-dessous est influencé par le blog de Daniel Holmberg sur les réseaux neuronaux graphiques en Python.

1. Créez l'objet DiGraph "H" du réseaux
2. Ajoutez des nœuds qui contiennent des étiquettes, des couleurs et des tailles différentes.
3. Ajoutez des arêtes pour créer une relation entre deux nœuds. Par exemple, "(0,1)" signifie que 0 a une dépendance directionnelle par rapport à 1. Nous allons créer des relations bidirectionnelles en ajoutant "(1,0)"
4. Extraire les couleurs et les tailles sous forme de listes
5. Tracez le graphique à l'aide de la fonction draw de 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)

Dans l'étape suivante, nous convertirons la structure de données d'un graphe directionnel en un graphe non directionnel à l'aide de la fonction to_undirected().  

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

Pourquoi est-il difficile d'analyser un graphique ?

Les structures de données basées sur les graphes présentent des inconvénients, et les scientifiques des données doivent les comprendre avant de développer des solutions basées sur les graphes.

1. Un graphe existe dans un espace non-euclidien. Il n'existe pas dans l'espace 2D ou 3D, ce qui rend l'interprétation des données plus difficile. Pour visualiser la structure dans l'espace 2D, vous devez utiliser différents outils de réduction de la dimensionnalité.
2. Les graphiques sont dynamiques ; ils n'ont pas de forme fixe. Il peut y avoir deux graphes visuellement différents, mais ils peuvent avoir des représentations similaires de la matrice d'adjacence. Il nous est donc difficile d'analyser les données à l'aide d'outils statistiques traditionnels. 
3. La taille et la dimensionnalité élevées augmentent la complexité du graphique pour les interprétations humaines. La structure dense avec de multiples nœuds et des milliers d'arêtes est plus difficile à comprendre et à interpréter. 

Qu'est-ce qu'un réseau de neurones graphiques (GNN) ?

Les réseaux neuronaux graphiques sont des types particuliers de réseaux neuronaux capables de travailler avec une structure de données graphiques. Ils sont fortement influencés par les réseaux neuronaux convolutifs (CNN) et l'intégration de graphes. Les GNN sont utilisés pour prédire les nœuds, les arêtes et les tâches basées sur les graphes. 

• Les CNN sont utilisés pour la classification des images. De même, les GNN sont appliqués à la structure d'un graphe (grille de pixels) pour prédire une classe. 
• Les réseaux neuronaux de récurrence sont utilisés pour la classification des textes. De même, les GNN sont appliqués à des structures graphiques où chaque mot est un nœud dans une phrase.  

Les GNN ont été introduits lorsque les réseaux neuronaux convolutifs n'ont pas permis d'obtenir des résultats optimaux en raison de la taille arbitraire du graphe et de la complexité de la structure. 

Image de Purvanshi Mehta

Le graphique d'entrée passe par une série de réseaux neuronaux. La structure graphique d'entrée est convertie en graph embedding, ce qui nous permet de conserver des informations sur les nœuds, les arêtes et le contexte global. 

Le vecteur de caractéristiques des nœuds A et C est ensuite transmis à la couche du réseau neuronal. Il agrège ces caractéristiques et les transmet à la couche suivante - neptune.ai.

Lisez notre tutoriel sur l'apprentissage profond ou suivez notre cours d'introduction à l'apprentissage profond pour en savoir plus sur les algorithmes et les applications d'apprentissage profond. 

Types de réseaux neuronaux graphiques

Il existe plusieurs types de réseaux neuronaux, et la plupart d'entre eux comportent une variante des réseaux neuronaux convolutifs. Dans cette section, nous allons nous familiariser avec les GNN les plus populaires. 

• Lesréseaux convolutifs graphiques (GCN) sont similaires aux CNN traditionnels. Il apprend les caractéristiques en inspectant les nœuds voisins. Les GNN agrègent les vecteurs des nœuds, transmettent le résultat à la couche dense et appliquent la non-linéarité à l'aide de la fonction d'activation. En bref, il se compose d'une convolution graphique, d'une couche linéaire et d'une fonction d'activation non apprenante. Il existe deux grands types de GCN : Réseaux convolutifs spatiaux et réseaux convolutifs spectraux.
• Encodeur automatique de graphes Les réseaux apprennent la représentation des graphes à l'aide d'un encodeur et tentent de reconstruire les graphes d'entrée à l'aide d'un décodeur. Le codeur et les décodeurs sont reliés par une couche de goulot d'étranglement. Ils sont couramment utilisés dans la prédiction des liens, car les encodeurs automatiques sont capables de gérer l'équilibre des classes. 
• Les réseaux neuronaux graphiques récurrents (RGNN) apprennent le meilleur modèle de diffusion et peuvent traiter des graphes multi-relationnels dans lesquels un seul nœud a plusieurs relations. Ce type de réseau neuronal graphique utilise des régularisateurs pour améliorer la régularité et éliminer les paramètres excessifs. Les RGNN utilisent moins de puissance de calcul pour produire de meilleurs résultats. Ils sont utilisés pour la génération de texte, la traduction automatique, la reconnaissance vocale, la génération de descriptions d'images, le marquage de vidéos et le résumé de texte.
• Les réseaux neuronaux graphiques à portes (GGNN) sont meilleurs que les RGNN pour l'exécution de tâches comportant des dépendances à long terme. Les réseaux neuronaux graphiques à portes améliorent les réseaux neuronaux graphiques récurrents en ajoutant un nœud, une arête et des portes temporelles sur les dépendances à long terme. À l'instar des unités récurrentes à portes (GRU), les portes sont utilisées pour mémoriser et oublier des informations dans des états différents. 

Si vous souhaitez en savoir plus sur les réseaux neuronaux récurrents (RNN), consultez le cours de DataCamp. Il vous présentera les différentes architectures de modèles RNN, les frameworks Keras et les applications RNN. 

Types de réseaux neuronaux graphiques Tâches

Vous trouverez ci-dessous quelques exemples de tâches GNN :

• Classification des graphes : nous l'utilisons pour classer les graphes dans différentes catégories. Ses applications sont l'analyse des réseaux sociaux et la classification des textes. 
• Classification des nœuds : cette tâche utilise les étiquettes des nœuds voisins pour prédire les étiquettes manquantes dans un graphique. 
• Prédiction de lien: prédit le lien entre une paire de nœuds dans un graphique avec une matrice d'adjacence incomplète. Il est couramment utilisé pour les réseaux sociaux. 
• Détection des communautés: divise les nœuds en plusieurs groupes sur la base de la structure des arêtes. Il apprend à partir des poids des arêtes, de la distance et des objets du graphe de manière similaire. 
• Graph Embedding (intégration de graphes) : cartographie des graphes en vecteurs, en préservant les informations pertinentes sur les nœuds, les arêtes et la structure.
• Génération de graphes: apprend à partir d'un échantillon de distribution de graphes à générer une nouvelle structure de graphe similaire. 

Image par l'auteur

Inconvénients des réseaux neuronaux graphiques

L'utilisation des GNN présente quelques inconvénients. Les comprendre nous aidera à déterminer quand utiliser GNNa et comment optimiser les performances de nos modèles d'apprentissage automatique. 

1. La plupart des réseaux neuronaux peuvent être approfondis pour obtenir de meilleures performances, alors que les réseaux neur onaux GNN sont des réseaux peu profonds comportant généralement trois couches. Cela nous empêche d'atteindre des performances de pointe sur de grands ensembles de données.
2. Les structures des graphes changent constamment, ce qui complique la formation d'un modèle. 
3. Le déploiement du modèle en production se heurte à des problèmes d'évolutivité, car ces réseaux sont coûteux en termes de calcul. Si vous avez une structure de graphe importante et complexe, il vous sera difficile de faire évoluer les GNN en production. 

Qu'est-ce qu'un réseau convolutionnel graphique (GCN) ?

La majorité des réseaux GNN sont des réseaux graphiques convolutifs, et il est important de les connaître avant de se lancer dans un tutoriel sur la classification des nœuds.  

La convolution dans les GCN est la même que dans les réseaux neuronaux convolutifs. Il multiplie les neurones avec des poids (filtres) pour apprendre à partir des caractéristiques des données. 

Il agit comme des fenêtres coulissantes sur des images entières pour apprendre les caractéristiques des cellules voisines. Le filtre utilise le partage des poids pour apprendre diverses caractéristiques faciales dans les systèmes de reconnaissance d'images - Towards Data Science. 

Transférez maintenant la même fonctionnalité aux réseaux graphiques convolutifs, où un modèle apprend les caractéristiques des nœuds voisins. La principale différence entre le GCN et le CNN est qu'il est développé pour travailler sur des structures de données non euclidiennes où l'ordre des nœuds et des arêtes peut varier. 

CNN vs GCN | Image Source

Apprenez-en plus sur les CNN de base en suivant le tutoriel sur les réseaux neuronaux convolutifs (CNN) avec TensorFlow. 

Il existe deux types de GCN : 

• Les réseaux convolutifs de graphes spatiaux utilisent des caractéristiques spatiales pour apprendre à partir de graphes situés dans l'espace spatial.  
• Les réseaux convolutifs spectraux utilisent la décomposition propre de la matrice laplacienne du graphe pour la propagation de l'information le long des nœuds. Ces réseaux s'inspirent de la propagation des ondes dans les signaux et les systèmes. 

Comment fonctionnent les GNN ? Construire un réseau neuronal graphique avec Pytorch

Nous construirons et entraînerons la convolution spectrale pour un modèle de classification des nœuds. Le code source est disponible dans ce manuel DataLab pour vous permettre d'expérimenter et d'exécuter votre premier modèle d'apprentissage automatique basé sur les graphes. 

Les exemples de codage sont influencés par la documentation géométrique de Pytorch. 

Pour commencer

Nous allons installer le paquetage Pytorch car pytorch_geometric est construit sur ce paquetage. 

!pip install -q torch

Nous utiliserons ensuite la version de torch pour installer torch-scatter et torch-sparse. Ensuite, nous installerons la dernière version de pytorch_geometricdepuis 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

Planétoïde Cora Dataset

Planetoid est un ensemble de données de réseaux de citations provenant de Cora, CiteSeer et PubMed. Les nœuds sont des documents avec des vecteurs de caractéristiques à 1433 dimensions, et les arêtes sont des liens de citation entre des articles de recherche. Il y a 7 classes, et nous allons entraîner le modèle à prédire les étiquettes manquantes. 

Nous allons ingérer l'ensemble de données Planetoid Cora, et normaliser les caractéristiques d'entrée du sac de mots. Ensuite, nous analyserons l'ensemble de données et le premier objet graphique. 

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)

L'ensemble de données Cora comporte 2708 nœuds, 10 556 arêtes, 1433 caractéristiques et 7 classes. Le premier objet comporte 2708 masques de formation, de validation et de test. Nous utiliserons ces masques pour entraîner et évaluer le modèle. 

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])

Classification des nœuds avec GNN

Nous allons créer une structure de modèle GCN qui contient deux couches GCNConv avec activation relu et un taux d'abandon de 0,5. Le modèle se compose de 16 canaux cachés.  

Couche GCN :

W(ℓ+1) est une matrice de poids transférable dans l'équation ci-dessus et Cw,v correspond à un coefficient de normalisation fixe pour chaque arête.

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)
  )

Visualisation du réseau GCN non entraîné

Visualisons les encastrements de nœuds des réseaux GCN non entraînés en utilisant sklearn.manifold.TSNE et matplotlib.pyplot. Il tracera un nœud à 7 dimensions intégrant un diagramme de dispersion en 2D.  

%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()

Nous évaluerons le modèle, puis nous ajouterons des données d'entraînement au modèle non entraîné afin de visualiser les différents nœuds et catégories. 

model.eval()

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

Formation GNN

Nous entraînerons notre modèle sur 100 époques en utilisant l'optimisation d'Adam et la fonction de perte d'entropie croisée. 

Dans la fonction de train, nous avons :

1. Effacer le dégradé
2. Effectuer une seule passe en avant
3. Calcul de la perte à l'aide des nœuds d'apprentissage
4. Calculer le gradient et mettre à jour les paramètres

Dans la fonction de test, nous avons :

1. Classe de nœuds prédite
2. Étiquette de classe extraite avec la probabilité la plus élevée
3. Vérifier combien de valeurs ont été prédites correctement
4. Création d'un taux de précision à partir de la somme des prédictions correctes divisée par le nombre total de nœuds. 

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

Évaluation du modèle

Nous allons maintenant évaluer le modèle sur un ensemble de données inédites à l'aide de la fonction de test, et comme vous pouvez le voir, nous avons obtenu de très bons résultats avec une précision de 81,5 %.  

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


>>> Test Accuracy: 0.8150

Nous allons maintenant visualiser l'intégration de la sortie d'un modèle entraîné afin de vérifier les résultats.

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

Comme nous pouvons le constater, le modèle formé a produit un meilleur regroupement des nœuds pour la même catégorie.

Modèle de formation GATConv

Dans la seconde, nous remplacerons les couches GCNConv par les couches GATConv. Le Graph Attention Networks utilise des couches d'auto-attention masquées pour remédier aux inconvénients de GCNConv et obtenir des résultats à la pointe de la technologie. 

Vous pouvez également essayer d'autres couches GNN et jouer avec les optimisations, les abandons et le nombre de canaux cachés pour obtenir de meilleures performances. 

Dans le code ci-dessous, nous venons de remplacer GCNConv par GATConv avec 8 têtes d'attention dans la première couche et 1 dans la seconde. 

Nous fixerons également :

• taux d'abandon scolaire à 0,6
• canaux cachés à 8
• taux d'apprentissage 0,005

Nous avons modifié la fonction de test pour trouver la précision d'un masque spécifique (valide, test). Il nous aidera à imprimer les résultats de la validation et du test pendant l'apprentissage du modèle. Nous stockons également les résultats de la validation et des tests dans un diagramme à courbes. 

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

Comme nous pouvons le constater, notre modèle n'est pas plus performant que GCNConv. Elle nécessite une optimisation des hyperparamètres ou un plus grand nombre d'époques pour obtenir des résultats de pointe. 

Évaluation du modèle

Dans la partie évaluation, nous visualisons les scores de validation et de test à l'aide du tracé linéaire de 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()

Après 60 époques, la validation et la précision des tests ont atteint une valeur stable de 0,8+/-0,02. 

Visualisons à nouveau le regroupement des nœuds du modèle GATConv.

model.eval()

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

Comme nous pouvons le constater, la couche GATConv a produit les mêmes résultats en matière de regroupement sur la même catégorie de nœuds. 

Nous pouvons réduire le surajustement en ajoutant un deuxième ensemble de données de validation et améliorer les performances du modèle en expérimentant différentes couches GCN à partir de pytoch_geometric. 

Le code source du tutoriel est disponible sur ce classeur DataLab. Créez une copie du classeur que vous pouvez exécuter.

Ajoutez une compétence en Deep Learning à votre CV en suivant le parcours de compétences Deep Learning in Python. Il vous présentera les algorithmes d'apprentissage profond, Keras, Pytorch et le framework Tensorflow.