Gruppo vertici in cluster utilizzando NetworkX

Question

Sto cercando di rappresentare graficamente alcuni grafici, e ho bisogno di raggruppare in cluster alcuni nodi che hanno caratteristiche comuni.

Sto usando NetworkX, e ho bisogno di fare qualcosa di simile con il grafico da this tutorial, dalla diapositiva 44, figura a sinistra.

Desidero disegnare una linea di delimitazione attorno a ciascun cluster. Il mio codice attuale è così:

vec = self.colors 
    colors = (linspace(0,1, len (set (vec)))* 20 + 10) 
    nx.draw_circular(g, node_color=array([colors[x] for x in vec])) 
    show() 

desidero trovare un esempio e vedere come posso usare NetworkX a raggrupparsi il grafico.

Answer 1

Non sono sicuro quale sia la tua domanda. Penso che tu stai chiedendo "come ottengo NetworkX di mettere alcuni nodi ravvicinati"

Prima mi lancio in una risposta, la documentazione di disegno per NetworkX è qui: http://networkx.lanl.gov/reference/drawing.html

Così quella cifra si sta chiedendo circa ha 4 diverse comunità che sono raggruppate in base al fatto di avere molti margini all'interno di ciascuna comunità e non molti all'esterno.

Se non si vuole mettere molto impegno in esso, spring_layout è spesso utile per mettere insieme le comunità strettamente legate. L'algoritmo di base di spring_layout agisce come se i bordi fossero molle (e i nodi si respingessero). Quindi molti bordi mantiene i nodi vicini. Nota che inizializza le posizioni casualmente, quindi ogni volta otterrai un risultato diverso.

Il modo più semplice per farlo è solo

nx.draw_spring(G) 

Ma forse si vuole di più. Se lo desideri, puoi correggere la posizione di ogni singolo nodo. Definisci un dict, di solito chiamato pos.

pos = {} 
for node in G.nodes_iter(): 
    pos[node] = (xcoord, ycoord). 

dove xcoord e ycoord sono le coordinate si desidera il nodo di essere al.

Poi basta fare draw_networkx (G, pos = pos)

Questo è spesso un sacco di fatica. Quindi, a volte basta dire che alcuni di loro devono essere in luoghi particolari, e lasciare che NetworkX fanno il resto

Definire fixedpos per un paio di nodi e quindi eseguire spring_layout dicendogli ciò che i nodi sono fissi e dandogli fixedpos come le posizioni iniziali. Quindi manterrà quelli fissi e si adattano a tutto il resto.

Ecco un codice che genera una rete che ha 4 parti completamente collegate e pochi altri bordi tra di loro. (in realtà genera una rete completa e quindi elimina tutti tranne alcuni bordi tra queste parti). Quindi lo disegna con un semplice layout a molla. Quindi fissa 4 di loro agli angoli di un quadrato e posiziona gli altri nodi attorno a quelle posizioni fisse.

import networkx as nx 
import random 
import pylab as py 
from math import floor 

G = nx.complete_graph(20) 

for edge in G.edges(): 
    if floor(edge[0]/5.)!=floor(edge[1]/5.): 
     if random.random()<0.95: 
      G.remove_edge(edge[0],edge[1]) 


nx.draw_spring(G) 
py.show() 


fixedpos = {1:(0,0), 6:(1,1), 11:(1,0), 16:(0,1)} 
pos = nx.spring_layout(G, fixed = fixedpos.keys(), pos = fixedpos) 

nx.draw_networkx(G, pos=pos) 

py.show() 

È inoltre possibile specificare i pesi ai bordi, passare i pesi per spring_layout e pesi più grandi vi dirà che per mantenere i nodi corrispondenti più vicini. Quindi, una volta identificate le comunità, aumentare i pesi all'interno delle comunità/cluster, se necessario, per tenerli vicini.

Si noti che è anche possibile specificare il colore per rendere ciascun nodo, quindi è semplice specificare il colore per ciascuna comunità/cluster.

Se si desidera disegnare le curve attorno a ciascuno di questi cluster, è necessario farlo tramite matplotlib.