NetworkX

Aperçu

NetworkX est un package Python pour créer, manipuler et analyser des réseaux et graphes complexes. Utilisez cette compétence quand vous travaillez avec des structures de données de réseau ou de graphe, notamment des réseaux sociaux, réseaux biologiques, systèmes de transport, réseaux de citations, graphes de connaissances, ou tout système impliquant des relations entre entités.

Quand utiliser cette compétence

Invoquez cette compétence quand les tâches impliquent :

Créer des graphes : Construire des structures de réseau à partir de données, ajouter des nœuds et des arêtes avec des attributs
Analyser des graphes : Calculer les mesures de centralité, trouver les chemins les plus courts, détecter les communautés, mesurer le clustering
Algorithmes de graphe : Exécuter des algorithmes standards comme Dijkstra, PageRank, arbres couvrants minimaux, flux maximal
Générer des réseaux : Créer des réseaux synthétiques (aléatoires, sans échelle, petit monde) pour les tests ou simulations
I/O de graphe : Lire ou écrire dans divers formats (listes d'arêtes, GraphML, JSON, CSV, matrices d'adjacence)
Visualisation : Dessiner et personnaliser les visualisations de réseau avec matplotlib ou des bibliothèques interactives
Comparaison de réseaux : Vérifier l'isomorphisme, calculer les métriques de graphe, analyser les propriétés structurelles

Capacités principales

1. Création et manipulation de graphe

NetworkX supporte quatre types de graphe principaux :

Graph : Graphes non orientés avec des arêtes simples
DiGraph : Graphes orientés avec des connexions unidirectionnelles
MultiGraph : Graphes non orientés permettant plusieurs arêtes entre nœuds
MultiDiGraph : Graphes orientés avec plusieurs arêtes

Créez des graphes en :

import networkx as nx

# Créer un graphe vide
G = nx.Graph()

# Ajouter des nœuds (peuvent être n'importe quel type hashable)
G.add_node(1)
G.add_nodes_from([2, 3, 4])
G.add_node("protein_A", type='enzyme', weight=1.5)

# Ajouter des arêtes
G.add_edge(1, 2)
G.add_edges_from([(1, 3), (2, 4)])
G.add_edge(1, 4, weight=0.8, relation='interacts')

Référence : Consultez references/graph-basics.md pour un guide complet sur la création, modification, examen et gestion des structures de graphe, y compris le travail avec les attributs et les sous-graphes.

2. Algorithmes de graphe

NetworkX fournit des algorithmes étendus pour l'analyse de réseau :

Chemins les plus courts :

# Trouver le chemin le plus court
path = nx.shortest_path(G, source=1, target=5)
length = nx.shortest_path_length(G, source=1, target=5, weight='weight')

Mesures de centralité :

# Centralité de degré
degree_cent = nx.degree_centrality(G)

# Centralité de proximité
betweenness = nx.betweenness_centrality(G)

# PageRank
pagerank = nx.pagerank(G)

Détection de communauté :

from networkx.algorithms import community

# Détecter les communautés
communities = community.greedy_modularity_communities(G)

Connectivité :

# Vérifier la connectivité
is_connected = nx.is_connected(G)

# Trouver les composantes connexes
components = list(nx.connected_components(G))

Référence : Consultez references/algorithms.md pour la documentation détaillée sur tous les algorithmes disponibles, y compris les chemins les plus courts, les mesures de centralité, le clustering, la détection de communauté, les flux, l'appariement, les algorithmes d'arbre et le parcours de graphe.

3. Générateurs de graphe

Créez des réseaux synthétiques pour les tests, simulations ou modélisations :

Graphes classiques :

# Graphe complet
G = nx.complete_graph(n=10)

# Graphe de cycle
G = nx.cycle_graph(n=20)

# Graphes connus
G = nx.karate_club_graph()
G = nx.petersen_graph()

Réseaux aléatoires :

# Graphe aléatoire Erdős-Rényi
G = nx.erdos_renyi_graph(n=100, p=0.1, seed=42)

# Réseau sans échelle Barabási-Albert
G = nx.barabasi_albert_graph(n=100, m=3, seed=42)

# Réseau petit monde Watts-Strogatz
G = nx.watts_strogatz_graph(n=100, k=6, p=0.1, seed=42)

Réseaux structurés :

# Graphe de grille
G = nx.grid_2d_graph(m=5, n=7)

# Arbre aléatoire
G = nx.random_tree(n=100, seed=42)

Référence : Consultez references/generators.md pour la couverture complète de tous les générateurs de graphe, y compris les graphes classiques, les modèles aléatoires, les treillis, les graphes bipartites et les modèles de réseau spécialisés avec des paramètres détaillés et des cas d'utilisation.

4. Lecture et écriture de graphes

NetworkX supporte de nombreux formats de fichier et sources de données :

Formats de fichier :

# Liste d'arêtes
G = nx.read_edgelist('graph.edgelist')
nx.write_edgelist(G, 'graph.edgelist')

# GraphML (préserve les attributs)
G = nx.read_graphml('graph.graphml')
nx.write_graphml(G, 'graph.graphml')

# GML
G = nx.read_gml('graph.gml')
nx.write_gml(G, 'graph.gml')

# JSON
data = nx.node_link_data(G)
G = nx.node_link_graph(data)

Intégration Pandas :

import pandas as pd

# À partir d'un DataFrame
df = pd.DataFrame({'source': [1, 2, 3], 'target': [2, 3, 4], 'weight': [0.5, 1.0, 0.75]})
G = nx.from_pandas_edgelist(df, 'source', 'target', edge_attr='weight')

# Vers un DataFrame
df = nx.to_pandas_edgelist(G)

Formats de matrice :

import numpy as np

# Matrice d'adjacence
A = nx.to_numpy_array(G)
G = nx.from_numpy_array(A)

# Matrice creuse
A = nx.to_scipy_sparse_array(G)
G = nx.from_scipy_sparse_array(A)

Référence : Consultez references/io.md pour la documentation complète sur tous les formats I/O, y compris CSV, bases de données SQL, Cytoscape, DOT, et les conseils de sélection de format pour différents cas d'utilisation.

5. Visualisation

Créez des visualisations de réseau claires et informatives :

Visualisation basique :

import matplotlib.pyplot as plt

# Dessin simple
nx.draw(G, with_labels=True)
plt.show()

# Avec disposition
pos = nx.spring_layout(G, seed=42)
nx.draw(G, pos=pos, with_labels=True, node_color='lightblue', node_size=500)
plt.show()

Personnalisation :

# Colorer par degré
node_colors = [G.degree(n) for n in G.nodes()]
nx.draw(G, node_color=node_colors, cmap=plt.cm.viridis)

# Taille par centralité
centrality = nx.betweenness_centrality(G)
node_sizes = [3000 * centrality[n] for n in G.nodes()]
nx.draw(G, node_size=node_sizes)

# Poids des arêtes
edge_widths = [3 * G[u][v].get('weight', 1) for u, v in G.edges()]
nx.draw(G, width=edge_widths)

Algorithmes de disposition :

# Disposition ressort (force-dirigée)
pos = nx.spring_layout(G, seed=42)

# Disposition circulaire
pos = nx.circular_layout(G)

# Disposition Kamada-Kawai
pos = nx.kamada_kawai_layout(G)

# Disposition spectrale
pos = nx.spectral_layout(G)

Qualité publication :

plt.figure(figsize=(12, 8))
pos = nx.spring_layout(G, seed=42)
nx.draw(G, pos=pos, node_color='lightblue', node_size=500,
        edge_color='gray', with_labels=True, font_size=10)
plt.title('Network Visualization', fontsize=16)
plt.axis('off')
plt.tight_layout()
plt.savefig('network.png', dpi=300, bbox_inches='tight')
plt.savefig('network.pdf', bbox_inches='tight')  # Format vectoriel

Référence : Consultez references/visualization.md pour la documentation extensive sur les techniques de visualisation, y compris les algorithmes de disposition, les options de personnalisation, les visualisations interactives avec Plotly et PyVis, les réseaux 3D et la création de figures de qualité publication.

Travailler avec NetworkX

Installation

Assurez-vous que NetworkX est installé :

# Vérifier l'installation
import networkx as nx
print(nx.__version__)

# Installer si nécessaire (via bash)
# uv pip install networkx
# uv pip install networkx[default]  # Avec dépendances optionnelles

Motif de flux de travail courant

La plupart des tâches NetworkX suivent ce motif :

Créer ou charger un graphe :

# À partir de zéro
G = nx.Graph()
G.add_edges_from([(1, 2), (2, 3), (3, 4)])

# Ou charger à partir d'un fichier/données
G = nx.read_edgelist('data.txt')

Examiner la structure :

print(f"Nodes: {G.number_of_nodes()}")
print(f"Edges: {G.number_of_edges()}")
print(f"Density: {nx.density(G)}")
print(f"Connected: {nx.is_connected(G)}")

Analyser :

# Calculer les métriques
degree_cent = nx.degree_centrality(G)
avg_clustering = nx.average_clustering(G)

# Trouver des chemins
path = nx.shortest_path(G, source=1, target=4)

# Détecter les communautés
communities = community.greedy_modularity_communities(G)

Visualiser :

pos = nx.spring_layout(G, seed=42)
nx.draw(G, pos=pos, with_labels=True)
plt.show()

Exporter les résultats :

# Sauvegarder le graphe
nx.write_graphml(G, 'analyzed_network.graphml')

# Sauvegarder les métriques
df = pd.DataFrame({
    'node': list(degree_cent.keys()),
    'centrality': list(degree_cent.values())
})
df.to_csv('centrality_results.csv', index=False)

Considérations importantes

Précision des nombres décimaux : Quand des graphes contiennent des nombres décimaux, tous les résultats sont intrinsèquement approximatifs en raison des limitations de précision. Cela peut affecter les résultats des algorithmes, particulièrement dans les calculs de minimum/maximum.

Mémoire et performance : Chaque fois qu'un script s'exécute, les données de graphe doivent être chargées en mémoire. Pour les grands réseaux :

Utilisez les structures de données appropriées (matrices creuses pour les grands graphes creux)
Envisagez de charger uniquement les sous-graphes nécessaires
Utilisez des formats de fichier efficaces (pickle pour les objets Python, formats compressés)
Exploitez les algorithmes approximatifs pour les très grands réseaux (p. ex., paramètre k dans les calculs de centralité)

Types de nœuds et d'arêtes :

Les nœuds peuvent être n'importe quel objet Python hashable (nombres, chaînes, tuples, objets personnalisés)
Utilisez des identifiants significatifs pour plus de clarté
Quand vous supprimez des nœuds, toutes les arêtes incidentes sont automatiquement supprimées

Graines aléatoires : Définissez toujours des graines aléatoires pour la reproductibilité dans la génération de graphes aléatoires et les dispositions force-dirigées :

G = nx.erdos_renyi_graph(n=100, p=0.1, seed=42)
pos = nx.spring_layout(G, seed=42)

Référence rapide

Opérations basiques

# Créer
G = nx.Graph()
G.add_edge(1, 2)

# Interroger
G.number_of_nodes()
G.number_of_edges()
G.degree(1)
list(G.neighbors(1))

# Vérifier
G.has_node(1)
G.has_edge(1, 2)
nx.is_connected(G)

# Modifier
G.remove_node(1)
G.remove_edge(1, 2)
G.clear()

Algorithmes essentiels

# Chemins
nx.shortest_path(G, source, target)
nx.all_pairs_shortest_path(G)

# Centralité
nx.degree_centrality(G)
nx.betweenness_centrality(G)
nx.closeness_centrality(G)
nx.pagerank(G)

# Clustering
nx.clustering(G)
nx.average_clustering(G)

# Composantes
nx.connected_components(G)
nx.strongly_connected_components(G)  # Orienté

# Communauté
community.greedy_modularity_communities(G)

Référence rapide I/O fichier

# Lire
nx.read_edgelist('file.txt')
nx.read_graphml('file.graphml')
nx.read_gml('file.gml')

# Écrire
nx.write_edgelist(G, 'file.txt')
nx.write_graphml(G, 'file.graphml')
nx.write_gml(G, 'file.gml')

# Pandas
nx.from_pandas_edgelist(df, 'source', 'target')
nx.to_pandas_edgelist(G)

Ressources

Cette compétence inclut une documentation de référence complète :

references/graph-basics.md

Guide détaillé sur les types de graphe, la création et modification de graphes, l'ajout de nœuds et d'arêtes, la gestion des attributs, l'examen de la structure et le travail avec les sous-graphes.

references/algorithms.md

Couverture complète des algorithmes NetworkX, y compris les chemins les plus courts, les mesures de centralité, la connectivité, le clustering, la détection de communauté, les algorithmes de flux, les algorithmes d'arbre, l'appariement, la coloration, l'isomorphisme et le parcours de graphe.

references/generators.md

Documentation complète sur les générateurs de graphe, y compris les graphes classiques, les modèles aléatoires (Erdős-Rényi, Barabási-Albert, Watts-Strogatz), les treillis, les arbres, les modèles de réseau social et les générateurs spécialisés.

references/io.md

Guide complet pour lire et écrire des graphes dans divers formats : listes d'arêtes, listes d'adjacence, GraphML, GML, JSON, CSV, DataFrames Pandas, tableaux NumPy, matrices creuses SciPy, intégration de bases de données et directives de sélection de format.

references/visualization.md

Documentation extensive sur les techniques de visualisation, y compris les algorithmes de disposition, la personnalisation de l'apparence des nœuds et des arêtes, les étiquettes, les visualisations interactives avec Plotly et PyVis, les réseaux 3D, les dispositions bipartites et la création de figures de qualité publication.

Ressources supplémentaires

Documentation officielle : https://networkx.org/documentation/latest/
Tutoriel : https://networkx.org/documentation/latest/tutorial.html
Galerie : https://networkx.org/documentation/latest/auto_examples/index.html
GitHub : https://github.com/networkx/networkx