Un GNN (Graph Neural Network) apprend sur des données reliées entre elles : comptes qui partagent un appareil, molécules, réseaux logistiques. Chaque élément met à jour sa représentation à partir de celle de ses voisins. Il repère ce qu'un modèle ligne à ligne ne voit pas, comme un réseau de fraudeurs dont chaque compte, pris seul, paraît banal.
Dites-moi qui vous fréquentez, je vous dirai qui vous êtes. Un compte ordinaire qui partage son téléphone avec trois comptes frauduleux mérite un second regard.
Chaque compte est un nœud avec ses variables. Deux comptes sont reliés s'ils partagent un appareil, une adresse ou un IBAN.
À chaque couche, un nœud agrège les représentations de ses voisins (moyenne pondérée dans un GCN), les combine avec la sienne et passe le tout dans un petit réseau. Deux couches, et l'information vient des voisins de ses voisins.
La représentation finale d'un compte résume ses propres variables et son entourage. Une couche de sortie donne la probabilité de fraude. L'apprentissage se fait sur les comptes au statut connu.
400 comptes normaux faiblement liés, et 5 groupes de 20 fraudeurs très liés entre eux. Chaque compte a 4 variables, à peine différentes chez les fraudeurs. Seuls 30 % des comptes ont un statut vérifié. Le jeu est simulé car aucun jeu de données du site n'a de structure de graphe.
Le GNN s'appuie sur les variables du compte et sur celles de son entourage. Un compte relié à des fraudeurs connus remonte, même si ses propres variables sont banales. L'équipe fraude reçoit une liste de comptes et de groupes à examiner.
Le rappel dit quelle part des fraudeurs est retrouvée, la précision quelle part des alertes est fondée. On compare au même modèle sans le graphe : l'écart mesure ce que les liens apportent.
Noms donnés pour PyTorch Geometric.
Le choix le plus important : quels liens (appareil, IBAN, transaction), orientés ou non, pondérés ou non. Un mauvais graphe donne un mauvais modèle, quelle que soit l'architecture.
Chaque couche élargit le voisinage d'un saut. 2 à 3 suffisent en général ; au-delà, les représentations des nœuds finissent par se ressembler toutes (sur-lissage).
GCN fait une moyenne pondérée des voisins. GraphSAGE échantillonne les voisins et passe mieux à l'échelle. GAT apprend un poids d'attention par voisin.
16 à 128 neurones par couche, avec dropout et weight_decay pour limiter le surapprentissage quand peu de nœuds sont étiquetés.
# Fraude en réseau : GNN (GCN) en Python
import networkx as nx
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv
from torch_geometric.utils import to_undirected
from sklearn.metrics import classification_report
torch.manual_seed(42)
# Simulation : 400 comptes normaux et 5 réseaux de 20 fraudeurs très liés entre eux
# (un lien = un appareil, une adresse ou un IBAN partagé)
tailles = [400, 20, 20, 20, 20, 20]
probas = [[0.01 if i == j == 0 else 0.3 if i == j else 0.002 for j in range(6)] for i in range(6)]
G = nx.stochastic_block_model(tailles, probas, seed=42)
liens = to_undirected(torch.tensor(list(G.edges)).t().contiguous())
fraude = torch.tensor([int(G.nodes[n]["block"] > 0) for n in G.nodes])
X = torch.randn(len(fraude), 4) + 0.5 * fraude[:, None] # variables du compte, peu parlantes seules
connu = torch.rand(len(fraude)) < 0.3 # 30 % des comptes ont un statut vérifié
# Deux couches de convolution sur graphe : chaque compte agrège ses voisins, puis les voisins de ses voisins
c1, c2 = GCNConv(4, 16), GCNConv(16, 2)
def predire(x):
return c2(F.relu(c1(x, liens)), liens)
optim = torch.optim.Adam(list(c1.parameters()) + list(c2.parameters()), lr=0.01, weight_decay=5e-4)
for epoque in range(200):
optim.zero_grad()
perte = F.cross_entropy(predire(X)[connu], fraude[connu])
perte.backward()
optim.step()
# Évaluation sur les comptes au statut inconnu
prevu = predire(X).argmax(dim=1)
print(classification_report(fraude[~connu].numpy(), prevu[~connu].numpy(), target_names=["normal", "fraude"]))Les GNN se pratiquent en Python (PyTorch Geometric, DGL) : pas d'équivalent R courant en entreprise.
Un ensemble de nœuds (clients, comptes, produits, atomes) reliés par des liens (transactions, partages, liaisons chimiques). Beaucoup de données d'entreprise en contiennent un sans le dire : il suffit de relier les lignes qui partagent un identifiant.
Ce sont trois façons d'agréger les voisins. Le GCN fait une moyenne pondérée par le nombre de liens. GraphSAGE échantillonne un nombre fixe de voisins, ce qui passe à l'échelle et s'applique à de nouveaux nœuds. GAT apprend un poids d'attention pour chaque voisin.
Non. Une simple liste de liens (deux colonnes d'identifiants) suffit à PyTorch Geometric. Une base graphe comme Neo4j aide surtout à stocker, explorer et mettre à jour de grands graphes en production.
Ne voit que les variables de chaque ligne. La comparaison avec le GNN mesure ce qu'apporte le graphe.
Voir la fiche → l'alternative pragmatiqueSur des variables de réseau calculées à la main (degré, voisins frauduleux), il fait souvent une grande partie du chemin.
Voir la fiche → sans étiquettesDécoupe le graphe en communautés denses. Utile pour repérer des groupes suspects quand aucun fraudeur n'est connu.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus