5  Visualiser ses données

Différents algorithmes de placement des sommets sont disponibles, certaines étant adaptés à des types précis de réseaux (bipartite_layout, planar_layout, multipartite_layout).

#graphe de Petersen
#pour les plus curieuses : https://fr.wikipedia.org/wiki/Graphe_de_Petersen
G = nx.petersen_graph()

# algorithmes de visualisation
# juxtaposer des fenêtres
fig, ax = plt.subplots(3, 2, figsize = (9,8)) # 3 lignes, 2 colonnes
nx.draw_networkx(G, ax = ax[0,0])             # ax[0,0] : à placer sur la première ligne, première colonne
ax[0,0].set_title('Default (Spring)')         # titre de la figure
nx.draw_networkx(G, pos = nx.random_layout(G), ax = ax[0,1])
ax[0,1].set_title('Random layout')
nx.draw_networkx(G, pos = nx.shell_layout(G), ax = ax[1,0])
ax[1,0].set_title('Shell layout')
nx.draw_networkx(G, pos = nx.spectral_layout(G), ax = ax[1,1])
ax[1,1].set_title('Spectral layout')
nx.draw_networkx(G, pos = nx.kamada_kawai_layout(G), ax = ax[2,0])
ax[2,0].set_title('Kamada Kawai layout')
nx.draw_networkx(G, pos = nx.spiral_layout(G), ax = ax[2,1])
ax[2,1].set_title('Spiral layout')

Text(0.5, 1.0, 'Spiral layout')

Il est évidemment possible de modifier l’apparence des sommets et des liens et, par exemple, de faire varier la taille ou la couleur en fonction d’un attribut. Il est souvent nécessaire de créer au préalable un dictionnaire permettant de faire varier le paramètre graphique voulu selon un indicateur donné, par exemple faire varier la taille des sommets selon le degré.

Les exemples ci-dessous ne prétendent pas à l’exhaustivité mais illustrent l’utilisation de quelques paramètres graphiques d’usage courant.

# création du dictionnaire pour les degrés
d = dict(GU.degree)

# création d'une liste des intensités
weights = [GU[u][v]['weight'] for u,v in GU.edges]

nx.draw_networkx(GU,
               pos = nx.spring_layout(GU),  # algorithme de placement
               node_color = 'orange',  # couleur des sommets
               alpha = 0.8,            # transparence
               nodelist= d.keys(),     # liste des sommets      
               node_size = [v * 20 for v in d.values()], # taille des sommets
               edge_cmap=plt.cm.Blues, # palette de couleurs
               edge_color = weights,   # couleur des liens
               with_labels=False,      # affichage des labels
               width=4)                # épaisseur des liens

# faire varier teinte et épaisseur des liens
# diviser les intensités par 100

weigh2 = [i/100 for i in weights]

nx.draw_networkx(GU,
               pos = nx.kamada_kawai_layout(GU),
               node_color = 'orange', 
               alpha = 0.8,
               nodelist= d.keys(), 
               node_size = [v * 20 for v in d.values()], 
               edge_cmap=plt.cm.Blues,
               edge_color = weights,
               with_labels = False,
               width=weigh2)

Si on souhaite produire plusieurs figures avec la même apparence, le plus simple est de définir au préalable les options de visualisation puis de les appeler.

# définir les options de visualisation
options = {
      'node_color' : 'orange',
      'node_size'  : 40, 
      'edge_color' : 'blue',
      'width' : 1,
      'alpha' : 0.8,
      'with_labels': False
    }

# visualiser
nx.draw_networkx(G, **options)

On trouve en ligne des exemples permettant de tester d’autres types de visualisation (matrice, edge-bundling, etc.). Ces points seront évoqués dans une version ultérieure de ce tutoriel.