Visualisation d'un graphique non orienté trop grand pour GraphViz?
J'ai besoin de conseils pour rendre un graphe non orienté avec 178 000 nœuds et 500 000 arêtes. J'ai essayé Neato, Tulip et Cytoscape. Neato ne se rapproche même pas à distance, et Tulip et Cytoscape affirment qu'ils peuvent le gérer mais ne semblent pas en mesure de le faire. (Tulip ne fait rien et Cytoscape prétend fonctionner, puis s'arrête.)
Je voudrais juste un fichier au format vectoriel (ps ou pdf) avec une disposition à distance raisonnable des nœuds.
Graphviz lui-même fournit une solution pour le rendu de grands graphiques.
À savoir, Graphviz inclut sfdp, une version à plusieurs échelles de fdp (également dans graphviz, similaire à neato) pour la mise en page de grands graphiques non dirigés qui a été utile pour dessiner de grands graphiques (nœuds 70k, bords 500k) dans mon projet .
Vous pouvez trouver la documentation de ce logiciel sur le site Web de graphviz lui-même à http://www.graphviz.org/
Pour plus d'informations, un article décrivant les techniques sous-jacentes et des exemples peut être trouvé ici: http://yifanhu.net/PUB/graph_draw_small.pdf
Je vous suggère de commencer par effectuer un prétraitement des données, par exemple de réduire les nœuds en clusters, puis de visualiser les clusters. La réduction réduira le nombre de nœuds et facilitera le rendu du graphique résultant pour des algorithmes tels que Kamada-Kawai ou Fruchterman-Reingold.
Si vous avez vraiment besoin de visualiser 500 000 nœuds, pouvez-vous envisager d'utiliser une disposition circulaire simple. Cela sera facile à rendre sans les problèmes des algorithmes basés sur la force. Jetez un œil à Circos: http://mkweb.bcgsc.ca/circos/
Circos est une visualisation de graphique développée par des bio-informaticiens qui est conçue pour visualiser les génomes et autres ensembles de données extrêmement volumineux et complexes.
C'est un paquet basé sur Perl, j'espère que ce n'est pas problématique.
J'ai eu de bons résultats en utilisant la bibliothèque graph-tool en python. Le graphique ci-dessous a 1 490 nœuds et 19 090 bords - il a fallu environ 5 minutes pour effectuer le rendu sur mon ordinateur portable.
Les données du graphique proviennent du réseau de blogs politiques décrit par Adamic et Glance dans "La blogosphère politique et les élections américaines de 2004" lien pdf ici . Si vous zoomez, vous pouvez voir les URL du blog pour chaque nœud.
Voici le code que j'ai utilisé pour le dessiner (blog http://ryancompton.net/2014/10/22/stochastic-block-model-based-Edge-bundles-in-graph-tool/ ) :
import graph_tool.all as gt
import math
g = gt.collection.data["polblogs"] # http://www2.scedu.unibo.it/roversi/SocioNet/AdamicGlanceBlogWWW.pdf
print(g.num_vertices(), g.num_edges())
#reduce to only connected nodes
g = gt.GraphView(g,vfilt=lambda v: (v.out_degree() > 0) and (v.in_degree() > 0) )
g.purge_vertices()
print(g.num_vertices(), g.num_edges())
#use 1->Republican, 2->Democrat
red_blue_map = {1:(1,0,0,1),0:(0,0,1,1)}
plot_color = g.new_vertex_property('vector<double>')
g.vertex_properties['plot_color'] = plot_color
for v in g.vertices():
plot_color[v] = red_blue_map[g.vertex_properties['value'][v]]
#Edge colors
alpha=0.15
Edge_color = g.new_Edge_property('vector<double>')
g.Edge_properties['Edge_color']=Edge_color
for e in g.edges():
if plot_color[e.source()] != plot_color[e.target()]:
if plot_color[e.source()] == (0,0,1,1):
#orange on dem -> rep
Edge_color[e] = (255.0/255.0, 102/255.0, 0/255.0, alpha)
else:
Edge_color[e] = (102.0/255.0, 51/255.0, 153/255.0, alpha)
#red on rep-rep edges
Elif plot_color[e.source()] == (1,0,0,1):
Edge_color[e] = (1,0,0, alpha)
#blue on dem-dem edges
else:
Edge_color[e] = (0,0,1, alpha)
state = gt.minimize_nested_blockmodel_dl(g, deg_corr=True)
bstack = state.get_bstack()
t = gt.get_hierarchy_tree(bstack)[0]
tpos = pos = gt.radial_tree_layout(t, t.vertex(t.num_vertices() - 1), weighted=True)
cts = gt.get_hierarchy_control_points(g, t, tpos)
pos = g.own_property(tpos)
b = bstack[0].vp["b"]
#labels
text_rot = g.new_vertex_property('double')
g.vertex_properties['text_rot'] = text_rot
for v in g.vertices():
if pos[v][0] >0:
text_rot[v] = math.atan(pos[v][1]/pos[v][0])
else:
text_rot[v] = math.pi + math.atan(pos[v][1]/pos[v][0])
gt.graph_draw(g, pos=pos, vertex_fill_color=g.vertex_properties['plot_color'],
vertex_color=g.vertex_properties['plot_color'],
Edge_control_points=cts,
vertex_size=10,
vertex_text=g.vertex_properties['label'],
vertex_text_rotation=g.vertex_properties['text_rot'],
vertex_text_position=1,
vertex_font_size=9,
Edge_color=g.Edge_properties['Edge_color'],
vertex_anchor=0,
bg_color=[0,0,0,1],
output_size=[4024,4024],
output='polblogs_blockmodel.png')
Mathematica pourrait très probablement le gérer, mais je dois admettre que ma première réaction a été dans le sens du commentaire qui disait "prenez un morceau de papier et coloriez-le en noir". N'y a-t-il aucun moyen de réduire la densité du graphique?
Un problème possible est que vous semblez rechercher la mise en page, pas seulement le rendu. Je n'ai aucune connaissance des caractéristiques Big O des mises en page implémentées par divers outils, mais intuitivement, je suppose que cela pourrait prendre un temps long pour être présenté autant de données.
Doit-il être vraiment précis?
Selon ce que vous essayez d'accomplir, il peut être suffisant de représenter graphiquement 10% ou 1% du volume de données. (bien sûr, cela peut aussi être complètement inutile, mais tout dépend de la finalité de la visualisation)
BioFabric ( www.BioFabric.org ) est un autre outil pour visualiser de grands graphiques. Il devrait être capable de gérer le réseau décrit (178 000 nœuds et 500 000 bords), bien que la configuration initiale puisse prendre un certain temps. Le réseau affiché ici (de la collection de jeux de données du grand réseau de Stanford) est le réseau Web de Stanford, qui compte 281 903 nœuds et 2 312 497 arêtes:
L'évolutivité de BioFabric est due au fait qu'il représente les nœuds non pas comme des points, mais comme des lignes horizontales. Les bords sont alors représentés sous forme de lignes verticales. Pour une certaine intuition sur la façon dont cela fonctionne, il y a le Super-Quick BioFabric Demo , qui est un petit réseau qui est animé en utilisant D3.
L'application principale est écrite en Java. Pour le moment, il ne peut exporter que des images PNG, pas des PDF. Il existe une option d'exportation PDF PDF de RBioFabric , bien qu'il s'agisse d'une implémentation très simple qui ne peut pas encore gérer de très gros réseaux.
Divulgation complète: BioFabric est un outil que j'ai écrit.
Je m'attends à ce que la mise en cluster Edge ( http://www.visualcomplexity.com/vc/project_details.cfm?id=679&index=679&domain= ) aiderait. Cette technique regroupe les bords associés, réduisant la complexité visuelle du graphique. Vous devrez peut-être implémenter l'algorithme vous-même.
Vous pouvez essayer aiSee: http://www.aisee.com/manual/unix/56.htm
Vous pouvez proposer une version filtrée du fichier aux développeurs de ces outils en tant que scénario de débogage, si tout le reste échoue.
Découvrez le GUESS basé sur Java/Jython: http://graphexploration.cond.org/
Large Graph Layout (LGL) project m'a beaucoup aidé avec un ptoblem similaire. Il gère la mise en page et possède une petite application Java pour dessiner les mises en page produites en 2D. )
Tout d'abord, je voudrais seconder la suggestion des aliekens d'essayer sfdp. Il s'agit de la version à grande échelle de Neato.
Comme le suggère OJW, vous pouvez également tracer simplement les nœuds dans R2. Vos bords fournissent en fait ce qu'il appelle un "ordre naturel". En particulier, vous pouvez tracer les composants des deuxième et troisième vecteurs propres du graphe normalisé laplacien. Ceci est la matrice L in cette page wikipedia sur le clustering spectral . Vous devriez être capable d'écrire cette matrice sans comprendre l'algèbre linéaire derrière elle. Ensuite, vous avez réduit votre problème à calculer approximativement les premiers vecteurs propres d'une grande matrice clairsemée. Cela se fait traditionnellement par des méthodes itératives et est implémenté dans des packages d'algèbre linéaire standard. Cette méthode doit évoluer jusqu'à de très grands graphiques.
Vous pouvez également essayer NAViGaTOR (divulgation: je suis l'un des développeurs de ce logiciel). Nous avons réussi à visualiser des graphiques avec jusqu'à 1,7 million d'arêtes. Bien que ces grands réseaux soient difficiles à manipuler (l'interface utilisateur deviendra lente). Cependant, il utilise OpenGL pour la visualisation, donc une partie de la surcharge est transférée sur la carte graphique.
Notez également que vous devrez augmenter les paramètres de mémoire dans la boîte de dialogue Fichier-> Préférences avant d'ouvrir avec succès un réseau de cette taille.
Enfin, comme le soulignent la plupart des autres réponses, il vaut mieux réorganiser vos données en quelque chose de plus petit et de plus significatif.
Je ne pense pas que vous puissiez vous rapprocher à distance de la visualisation dans une disposition plate.
J'ai été intrigué par Graphiques hyperboliques, décrits dans ce document de recherche depuis un certain temps. Essayez le logiciel de SourceForge .
Une autre idée consiste simplement à représenter graphiquement les nœuds à l'aide d'un TreeMap comme vu à Panopticode .
Il y a une liste d'applications ici: http://www.mkbergman.com/?p=414
Morse et LGL sont deux outils censés convenir aux grands graphiques. Cependant, les deux semblent nécessiter la saisie de graphiques sous forme de fichiers texte dans leur propre format spécial, ce qui pourrait être pénible.