Les données ne sont pas toujours des tableaux bien rangés. Parfois, la vraie information se cache dans les liens : qui connaît qui sur un réseau social, quel site pointe vers quel autre, quelle gare relie quelle ville, quel module importe quel autre. Pour modéliser ces relations, on utilise des graphes. Et en Python, la référence absolue s'appelle NetworkX.
NetworkX est la bibliothèque de graphes la plus utilisée de l'écosystème Python, adoptée aussi bien par des universités que par des labos et des entreprises. Elle embarque des centaines d'algorithmes prêts à l'emploi : plus court chemin, détection de communautés, mesures de centralité, et même le PageRank, l'algorithme qui a fait la fortune de Google. Dans ce tutoriel, tu vas construire un petit réseau social, mesurer l'influence de chacun de ses membres et visualiser le résultat en quelques lignes de code.
Les graphes sont partout derrière l'intelligence artificielle moderne. Les graphes de connaissances structurent ce que les modèles savent, les systèmes de recommandation cartographient les goûts de leurs utilisateurs, et la détection de fraude repère les comportements anormaux dans un réseau de transactions. Savoir les manipuler, c'est comprendre une bonne partie de la mécanique cachée sous le capot.
Prérequis et installation
Commence par installer trois paquets. NetworkX pour les graphes, Matplotlib pour l'affichage, et SciPy que NetworkX utilise en interne pour accélérer certains calculs comme le PageRank.
pip install networkx matplotlib scipyÉtape 1 — Créer ton graphe
Un graphe, ce sont des nœuds (les personnes, les pages, les villes) reliés par des arêtes (les relations). NetworkX propose plusieurs types de graphes : Graph pour des relations symétriques, puisque l'amitié est réciproque, et DiGraph pour des relations orientées, comme un site qui pointe vers un autre sans que l'inverse soit vrai. Pour commencer, on modélise un groupe d'amis : chaque tuple représente une amitié entre deux personnes.
import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
amis = [
("Alice", "Bob"), ("Alice", "Claire"), ("Alice", "David"),
("Bob", "Claire"), ("Claire", "David"), ("David", "Emma"),
("Emma", "Fabien"), ("Fabien", "Claire"), ("Bob", "Emma"),
]
G.add_edges_from(amis)
print("Nœuds :", G.number_of_nodes())
print("Arêtes :", G.number_of_edges())Résultat : 6 nœuds et 9 arêtes. Le graphe vit maintenant en mémoire. On peut l'interroger, le transformer, et lui faire cracher des réponses que tu ne devinerais pas à l'œil nu.
Étape 2 — Explorer la structure
Avant de lancer des algorithmes sophistiqués, regarde la forme du réseau. Le degré d'un nœud, c'est son nombre de connexions. Ses voisins, ce sont les nœuds directement reliés.
print("Degré d'Alice :", G.degree["Alice"])
print("Voisins d'Alice :", list(G.neighbors("Alice")))
print("Le graphe est-il connexe ?", nx.is_connected(G))Alice a 3 amis directs, et le graphe est connexe : tout le monde est joignable depuis n'importe qui. Une info utile avant d'aller plus loin.
Étape 3 — Mesurer l'influence avec le PageRank
C'est la partie amusante. Le PageRank, inventé par Larry Page et Sergey Brin en 1998, évalue l'importance d'un nœud selon qui le cite. L'idée est simple : un lien venant d'un nœud important vaut plus qu'un lien venant d'un nœud isolé. C'est exactement ce principe qui classe les résultats de Google. Ici, il nous dit qui est la personne la plus centrale du groupe.
pagerank = nx.pagerank(G)
top = sorted(pagerank.items(), key=lambda x: x[1], reverse=True)[:3]
for nom, score in top:
print(f"{nom} : {score:.3f}")Claire ressort en tête. Ce n'est pas un hasard : elle sert de pont entre plusieurs sous-groupes. Sans elle, le réseau se couperait en deux. C'est précisément ce genre d'intuition que les graphes rendent mesurable.
Étape 4 — Trouver le plus court chemin
Autre classique : relier deux points en passant par le moins d'intermédiaires possible. NetworkX implémente l'algorithme de Dijkstra et ses variantes. Pratique pour un GPS, un plan de métro, ou pour mesurer la distance sociale entre deux personnes.
chemin = nx.shortest_path(G, "Alice", "Fabien")
print("Chemin Alice -> Fabien :", chemin)
print("Longueur :", nx.shortest_path_length(G, "Alice", "Fabien"))Alice et Fabien ne se connaissent pas directement, mais deux sauts suffisent pour les relier. Sur un vrai réseau social de millions de personnes, ce calcul reste instantané.
Étape 5 — Visualiser le réseau
Un graphe se comprend mieux quand on le voit. NetworkX calcule des positions automatiques : spring_layout imite un système de ressorts qui rapproche les nœuds connectés et écarte les autres. Matplotlib se charge ensuite du dessin.
pos = nx.spring_layout(G, seed=42)
nx.draw(G, pos, with_labels=True, node_color="#4f8cff",
edge_color="#b0b0b0", node_size=2000, font_size=9, font_color="white")
plt.show()Étape 6 — Détecter des communautés
Dernier bonus avant de conclure : repérer des groupes cohérents à l'intérieur du réseau. C'est le principe de la détection de communautés, utile pour segmenter des clients, regrouper des articles similaires ou débusquer des clans dans un réseau social.
from networkx.algorithms import community
groupes = community.greedy_modularity_communities(G)
for i, groupe in enumerate(groupes, 1):
print(f"Communauté {i} :", sorted(groupe))L'algorithme découpe le graphe en groupes dont les membres sont plus connectés entre eux qu'avec le reste. Sur notre petit réseau, tu verras émerger deux communautés naturelles.
Pour aller plus loin
En six étapes, tu as construit un graphe, mesuré l'influence de ses membres, détecté des communautés et visualisé le résultat. Ce genre d'outil s'applique partout : détection de fraudes, en repérant des comptes qui forment une clique suspecte ; systèmes de recommandation, avec les amis de tes amis ; analyse de dépendances dans du code ; ou cartographie de communautés sur les réseaux sociaux.
NetworkX gère aussi des graphes de millions de nœuds, la lecture et l'écriture de formats standards comme GraphML ou GEXF, et des algorithmes plus poussés tels que la détection de communautés ou l'analyse de flux. Le point de départ reste toujours le même : des nœuds, des arêtes, et les algorithmes qui travaillent pour toi.
