def plot_all_graphs(map_graph, start_year, end_year, folder):
for year in range(start_year, end_year):
plt.title("Graph" + str(year), fontsize=15)
nx.draw_random(map_graph[str(year)], with_labels=False, node_size=100, node_color=[(0.73, 0.09, 0.19)],
node_cmap=cm.get_cmap("viridis"), edge_cmap=cm.get_cmap("binary"))
plt.savefig(folder + "Graph" + str(year) + ".png", format="PNG")
plt.show()
def draw_graph(graph, showLabels = True):
# extract nodes from graph
nodes = set([n1 for n1, n2 in graph] + [n2 for n1, n2 in graph])
# create network graph
G=nx.Graph()
# add nodes
for node in nodes:
G.add_node(node)
# add edges
for edge in graph:
G.add_edge(edge[0], edge[1])
# draw graph 1 in shell layout
pos = nx.shell_layout(G)
nx.draw(G, pos)
plt.figure()
# draw graph 2 with a random layout
# might need to zoom in to see edges
# labels are now on top of the nodes
nx.draw_random(G)
plt.figure()
nx.draw_spring(G, node_size=100, with_labels=showLabels, font_size=16, edge_color="grey", width=0.5)
# draw graph 3 the standard way and save
plt.savefig("fig1.png")
plt.show()
def nx_topoPrint(self): if self.nx_topology is None: print [] else: print self.nx_topology.edges(data=True) nx.draw_random(self.nx_topology) plt.show()
def inventors_network(df, top_pairs=100):
# converting from pandas Series to list after dropping Empty/Null values
inventors = df["Inventors"].dropna().tolist()
# making dictionary for assignee (key) -> # of patents (value)
inventors_net = {}
for j in inventors:
inventor = j.split(";;")
for i in inventor:
for j in inventor:
if i != j:
key1 = i + ',' + j
key2 = j + ',' + i
if key1 not in inventors_net.keys(
) and key2 not in inventors_net.keys():
inventors_net[key1] = 1
elif key1 in inventors_net.keys():
inventors_net[key1] += 1
elif key2 in inventors_net.keys():
inventors_net[key2] += 1
# sorted dictionary from high number of patents to low
inventors_net_sorted = {
k: v
for k, v in sorted(
inventors_net.items(), key=lambda item: item[1], reverse=True)
}
# parameter to get top n invetors plot
out_net_inventor = dict(
itertools.islice(inventors_net_sorted.items(), top_pairs))
inventor1 = []
inventor2 = []
count = []
for i in out_net_inventor:
inven = i.split(',')
inventor1.append(inven[0])
inventor2.append(inven[1])
count.append(out_net_inventor[i])
df_net = pd.DataFrame({
'inventor1': inventor1,
'inventor2': inventor2,
'patent_count': count
})
print('Inventors Network')
G = nx.Graph()
G = nx.from_pandas_edgelist(df_net,
'inventor1',
'inventor2',
edge_attr='patent_count')
#count = [i['patent_count'] for i in dict(G.edges).values()]
#labels = [i for i in dict(G.nodes).keys()]
#labels = {i:i for i in dict(G.nodes).keys()}
plt.figure(figsize=(15, 15))
nx.draw_random(G, with_labels=True)
plt.show()
def draw_random_communities(self):
partition = self.find_partition()[1]
node_color=[float(partition[v]) for v in partition]
labels = self.compute_labels()
nx.draw_random(self.G,node_color=node_color, labels=labels)
plt.show()
plt.savefig("C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_random.pdf")
def __main__():
actors, movies = extract_from_json(
'data.json', NUM_MOVIES, NUM_ACTORS) # Get the ACTORS and MOVIES dict
actors, movies = make_graph(actors,
movies) # Draw the edges between these nodes
# movies = get_movies_of_actors(actors)
graph = nx.Graph()
create_graph(
graph, actors, movies
) # Add the nodes draw the edges between nodes in the networkx graph
node_colors, node_sizes = get_node_attrs(
graph) # Get the node colors and sizes
# Plot the graph
plt.figure(figsize=FIG_SIZE)
nx.draw_random(graph,
node_color=node_colors,
node_size=node_sizes,
with_labels=True)
plt.savefig('actor_movie_graph_random.png')
plt.figure(figsize=FIG_SIZE)
nx.draw(graph,
node_color=node_colors,
node_size=node_sizes,
with_labels=True)
plt.savefig('actor_movie_graph.png')
def generator_by_json(d):
G = nx.MultiDiGraph()
for link, links in d.items():
for link__ in links:
for link1, links1 in link__.items():
G.add_edge(link, link1)
for link2__ in links1:
for link3, links3 in link2__.items():
G.add_edge(link1, link3)
for link___ in links3:
G.add_edge(link3, link___)
plt.figure(figsize=(30, 30))
options = {
'node_color': 'red',
'node_size': 12,
'edge_color': 'blue',
'width': 0.07
}
print('q')
nx.write_gml(G, 'remote.gml')
nx.draw_random(G, with_labels=False, **options)
plt.savefig('foo.png')
def custom_edge_colors():
#create an empty graph
G = nx.Graph()
H=nx.path_graph(len(rez3))
G.add_nodes_from(H),
custom_node_color={}
custom_node_color["H"] = "g"
nx.draw_random(G, node_color=custom_node_color.values(), with_labels=False, node_size=5)
C = nx.Graph()
C.add_node("genom")
custom_node_color={}
custom_node_color["genom"] = "g"
nx.draw_random(C, node_color=custom_node_color.values(), with_labels=True, node_size=2500)
plt.show()
def load(file_name):
G = nx.MultiDiGraph()
d: dict = json.load(open(file_name))
for link, links in d.items():
for link__ in links:
link__: dict
for link1, links1 in link__.items():
link1: str
G.add_edge(link, link1)
for link2__ in links1:
for link3, links3 in link2__.items():
G.add_edge(link1, link3)
for link___ in links3:
G.add_edge(link3, link___)
plt.figure(figsize=(40, 40))
# nx.draw_networkx(G, node_color='green')
options = {
'node_color': 'red',
'node_size': 10,
'edge_color': 'blue',
'width': 0.08
}
nx.write_gml(G, 'remote.gml')
nx.draw_random(G, with_labels=False, **options)
# plt.show()
plt.savefig('foo.png')
def show_graph(self,
graph=None,
save_file=None,
drawing_type='internal',
pltshow=True):
import matplotlib.pyplot as plt
if graph is None:
shown_graph = self._connected_subgraph
else:
shown_graph = graph
plt.figure()
# pos = nx.spring_layout(shown_graph)
if drawing_type == 'internal':
pos = nx.shell_layout(shown_graph)
ax = plt.gca()
draw_network(shown_graph,
pos,
ax,
periodicity_vectors=self._periodicity_vectors)
ax.autoscale()
plt.axis('equal')
plt.axis('off')
if save_file is not None:
plt.savefig(save_file)
# nx.draw(self._connected_subgraph)
elif drawing_type == 'draw_graphviz':
import networkx
networkx.nx_pydot.graphviz_layout(shown_graph)
elif drawing_type == 'draw_random':
import networkx
networkx.draw_random(shown_graph)
if pltshow:
plt.show()
def countInformedNode3(G,t,info_source,info_other,N):
states= nx.get_node_attributes(G,'state')
count = 0
color_map=[]
if(N<500):
for x in states:
if(states[x]==info_source):
count=count+1
#informed
color_map.append("red")
elif(states[x]==(info_source+1%2)):
#bad information
color_map.append("blue")
else:
#uninformed
color_map.append("green")
plt.figure(t)
nx.draw_random(G,node_color = color_map,with_labels=True)
plt.savefig('static/foo'+str(t)+'.png')
if(count==N):
#print("all nodes are informed after "+str(t)+" rounds")
return True
# print("At the end of round "+str(t)+" there are "+str(count)+" informed node")
return False
def draw_network(G: Graph,
output_name: str,
type_of_network: str = None) -> None:
"""
Creates a drawing of the network, according to the selected type of network.
Args:
G (graph): the input graph
output_name (string): the output name
type_of_network (string): the type of network
Returns:
None. Just prints the image to a file into the folder data/
"""
if type_of_network == "planar":
nx.draw_planar(G, with_labels=True)
elif type_of_network == "circular":
nx.draw_circular(G, with_labels=True)
elif type_of_network == "random":
nx.draw_random(G, with_labels=True)
elif type_of_network == "spectral":
nx.draw_random(G, with_labels=True)
elif type_of_network == "kamada_kawai":
nx.draw_kamada_kawai(G, with_labels=True)
elif type_of_network == "spring":
nx.draw_spring(G, with_labels=True)
elif type_of_network == "shell":
nx.draw_shell(G, with_labels=True)
else:
nx.draw(G, with_labels=True)
plt.savefig("images/" + output_name + "network_" + str(type_of_network) +
".png")
plt.close()
def draw_graph(g, out_filename):
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
plt.savefig(out_filename)
def nx_topoPrint(self): if self.nx_topology is None: print [] else: print self.nx_topology.edges(data=True) nx.draw_random(self.nx_topology) plt.show()
def draw_graph(g, out_filename):
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
plt.savefig(out_filename)
def draw_graph(self, G, node_list=None, edge_colour='k', node_size=15, node_colour='r', graph_type='spring',
back_bone=None, side_chains=None, terminators=None):
# determine nodelist
if node_list is None:
node_list = G.nodes()
# determine labels
labels = {}
for l_atom in G.nodes_iter():
labels[l_atom] = l_atom.symbol
# draw graphs based on graph_type
if graph_type == 'circular':
nx.draw_circular(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'random':
nx.draw_random(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'spectral':
nx.draw_spectral(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'spring':
nx.draw_spring(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'shell':
nx.draw_shell(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
# elif graph_type == 'protein':
# self.draw_protein(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
# edge_color=edge_colour, node_color=node_colour, back_bone, side_chains, terminators)
else:
nx.draw_networkx(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
plt.show()
def draw_networkx_ex():
G = nx.dodecahedral_graph()
nx.draw(G)
plt.show()
nx.draw_networkx(G, pos=nx.spring_layout(G))
limits = plt.axis('off')
plt.show()
nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
plt.show()
edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
plt.show()
labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
plt.show()
edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
plt.show()
print("Circular layout")
nx.draw_circular(G)
plt.show()
print("Random layout")
nx.draw_random(G)
plt.show()
print("Spectral layout")
nx.draw_spectral(G)
plt.show()
print("Spring layout")
nx.draw_spring(G)
plt.show()
print("Shell layout")
nx.draw_shell(G)
plt.show()
print("Graphviz")
def draw():
pos = nx.spring_layout(H)
nx.draw_networkx_nodes(H, pos=pos, nodelist=H.nodes())
nx.draw_networkx_edges(H, pos=pos, edgelist=H.edges())
nx.draw_networkx_labels(H, pos=pos)
nx.draw_random(H)
plt.show()
def start_graph(Nomserie, type_graph):
print(type_graph)
options = {
'node_color': 'red',
'node_size': 200,
'width': 3,
}
if Nomserie == "Game of Thrones":
G1 = nx.read_graphml("data/got/GoT_S05E09_1039.graphml")
print(G1)
if Nomserie == "Breaking Bad":
G1 = nx.read_graphml("data/bb/BB_S03E11_598.graphml")
if Nomserie == "House of Card":
G1 = nx.read_graphml("data/hoc/HoC_S02E13_879.graphml")
G1.remove_nodes_from(nx.isolates(G1))
if type_graph == "Classical":
nx.draw_networkx(G1, pos=nx.spring_layout(G1))
if type_graph == "Random":
nx.draw_random(G1, **options, with_labels=True, font_weight='bold')
if type_graph == "Circular":
nx.draw_circular(G1, **options, with_labels=True, font_weight='bold')
if type_graph == "Spectral":
nx.draw_spectral(G1, **options, with_labels=True, font_weight='bold')
if type_graph == "Shell":
nx.draw_shell(G1, **options, with_labels=True, font_weight='bold')
plt.savefig("images/" + Nomserie + "_" + type_graph + ".jpg")
plt.close('all')
def draw_networkx_ex():
G = nx.dodecahedral_graph()
nx.draw(G)
plt.show()
nx.draw_networkx(G, pos=nx.spring_layout(G))
limits = plt.axis('off')
plt.show()
nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
plt.show()
edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
plt.show()
labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
plt.show()
edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
plt.show()
print("Circular layout")
nx.draw_circular(G)
plt.show()
print("Random layout")
nx.draw_random(G)
plt.show()
print("Spectral layout")
nx.draw_spectral(G)
plt.show()
print("Spring layout")
nx.draw_spring(G)
plt.show()
print("Shell layout")
nx.draw_shell(G)
plt.show()
print("Graphviz")
def draw_random_communities(self):
partition = self.find_partition()[1]
node_color = [float(partition[v]) for v in partition]
labels = self.compute_labels()
nx.draw_random(self.G, node_color=node_color, labels=labels)
plt.show()
plt.savefig(
"C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_random.pdf"
)
def sample1():
# 一定要建立一個物件，這物件就是包含所有的node跟edge
G = nx.random_graphs.barabasi_albert_graph(100, 1)
# nx.draw(G)
nx.draw_random(G)
# nx.draw_circular(G)
# nx.draw_spectral(G)
plt.savefig("test.png")
plt.show()
def drawgraph(self, G):
nx.draw(G)
plt.savefig(self.opts.o[0] + ".cluster_graph.png")
nx.draw_random(G)
plt.savefig(self.opts.o[0] + ".cluster_graph_random.png")
nx.draw_circular(G)
plt.savefig(self.opts.o[0] + ".cluster_graph_circular.png")
nx.draw_spectral(G)
plt.savefig(self.opts.o[0] + ".cluster_graph_spectral.png")
def drawplot(self, index):
if index == 0:
nx.draw_networkx(self.G, with_labels=False)
elif index == 1:
nx.draw_shell(self.G)
elif index == 2:
nx.draw_kamada_kawai(self.G, node_size=5, linewidths=0.5)
elif index == 3:
nx.draw_random(self.G)
def main(argv):
if len(argv) != 1:
print "usage: python compare-food.py <path/to/allr_recipes.txt>"
sys.exit(0)
file_path = argv[0]
# Change the criteria for the graphs here.
mix_criteria = ['Canada', 'Scandinavia']
recipes_list = []
count = 0
with open(file_path, 'r') as f:
for line in f:
split_line = line.split()
country = split_line[0]
if country in mix_criteria:
ingredients = split_line[1:]
recipes_list.append(ingredients)
count += 1
g_nx = nx.Graph()
for recipe in recipes_list:
edges = itertools.combinations(recipe, 2)
g_nx.add_edges_from(edges)
degrees = nx.degree(g_nx)
# filtered_nodes = [n for n in degrees if degrees[n] < 50]
# filtered_nodes = [n for n in degrees if 50 <= degrees[n] <= 100]
filtered_nodes = [n for n in degrees if degrees[n] > 100]
sub_graph = g_nx.subgraph(filtered_nodes)
ds = nx.degree(sub_graph)
plt.figure(figsize=(14, 14))
nx.draw_random(sub_graph,
with_labels=True,
nodelist=ds.keys(),
node_size=[d * 70 for d in ds.values()],
font_size=8,
edge_color='grey')
# nx.draw_random(g_nx, with_labels=True,
# nodelist=degrees.keys(), node_size=[d * 10 for d in degrees.values()],
# font_size=8, edge_color='grey')
# plt.show()
output_file = "-".join(mix_criteria) + ".elist.txt"
plt.savefig(output_file + "-subgraph.png")
print "Edge list is in: {}".format(output_file)
def main():
print("Graphing!")
G = nx.Graph()
G.add_nodes_from([1-3])
G.add_edge(1, 2)
nx.draw_random(G)
nx.draw_circular(G)
nx.draw_spectral(G)
plt.show()
def main():
print("Graphing!")
G = nx.Graph()
G.add_nodes_from([1 - 3])
G.add_edge(1, 2)
nx.draw_random(G)
nx.draw_circular(G)
nx.draw_spectral(G)
plt.show()
def demo_save_fig():
"""demo_save_fig"""
g = nx.Graph()
g.add_edges_from([(1, 2), (1, 3)])
g.add_node('sparm')
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
plt.savefig("g.png")
def demo_save_fig():
"""demo_save_fig"""
g = nx.Graph()
g.add_edges_from([(1, 2), (1, 3)])
g.add_node('sparm')
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
plt.savefig("g.png")
def draw(self):
# nx.draw_planar(self.G, with_labels=True, font_weight='bold')
# nx.draw_circular(self.G, with_labels=True, font_weight='bold')
# nx.draw_kamada_kawai(self.G, with_labels=True, font_weight='bold')
# nx.draw_spectral(self.G, with_labels=True, font_weight='bold')
nx.draw_random(self.G, with_labels=True, font_weight='bold')
# nx.draw_spring(self.G, with_labels=True, font_weight='bold')
# nx.draw_shell(self.G, with_labels=True, font_weight='bold')
plt.show()
def draw_network(G, name, path, save, circular):
if circular: nx.draw_circular(G)
else: nx.draw_random(G)
plt.axis('off')
plt.title(name, fontweight='bold', fontsize=12)
if save: plt.savefig(path + '_graph.pdf', bbox_inches='tight')
plt.close()
def showWGraph(n, W):
geneGraph = nx.DiGraph()
for i in range(n):
for j in range(n):
if (W[i, j] != 0):
geneGraph.add_edge(j, i)
nx.draw_random(geneGraph, with_labels=True)
plt.show()
def demo_write_doc():
"""demo_write_doc"""
g = nx.Graph()
g.add_edges_from([(1, 2), (1, 3)])
g.add_node('sparm')
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
nx.draw_graphviz(g)
nx.write_dot(g, 'g.dot')
def test_draw(self):
# hold(False)
N = self.G
nx.draw_spring(N)
pylab.savefig("test.png")
nx.draw_random(N)
pylab.savefig("test.ps")
nx.draw_circular(N)
pylab.savefig("test.png")
nx.draw_spectral(N)
pylab.savefig("test.png")
def draw_graph(G, file):
_deg = nx.degree(G)
deg = [(_deg[node] + 1) for node in G.nodes()]
nx.draw_random(G, node_size=deg, width=0.1, arrows=False)
print(f"Save snapshot to {graph_dir}{file[:-5]}.eps")
plt.savefig(f"{graph_dir}{file[:-5]}.eps")
for edge in G.edges(data=True):
print(edge)
break
def test_draw(self):
# hold(False)
N=self.G
nx.draw_spring(N)
pylab.savefig("test.png")
nx.draw_random(N)
pylab.savefig("test.ps")
nx.draw_circular(N)
pylab.savefig("test.png")
nx.draw_spectral(N)
pylab.savefig("test.png")
def demo_write_doc():
"""demo_write_doc"""
g = nx.Graph()
g.add_edges_from([(1, 2), (1, 3)])
g.add_node('sparm')
nx.draw(g)
nx.draw_random(g)
nx.draw_circular(g)
nx.draw_spectral(g)
nx.draw_graphviz(g)
nx.write_dot(g, 'g.dot')
def draw_curr(self, pos=None):
'''
Draw discovered graph
'''
plt.figure(1, figsize=(30, 30))
plt.clf()
self.sub = nx.subgraph(self.graph, self.active.union(self.possible_actions))
if pos is None:
nx.draw_random(self.sub, with_labels=True)
else:
nx.draw(self.sub, with_labels=True, pos=pos)
def show(self, mode=None):
if not mode:
nx.draw(self)
elif mode == 'random':
nx.draw_random(self)
elif mode == 'circular':
nx.draw_circular(self)
elif mode == 'spectral':
nx.draw_spectral(self)
plt.show()
def visualize(self): g = None if self.directed: g = nx.DiGraph() else: g = nx.Graph() g.add_edges_from(self.edges()) nx.draw_random(g) plt.show()
def nx_plot(r_graph,
cols_names,
simple=True,
labels=None,
graph_layout='shell',
node_size=1600,
node_color='blue',
node_alpha=0.3,
node_text_size=12,
edge_color='blue',
edge_alpha=0.3,
edge_tickness=1,
edge_text_pos=0.3,
text_font='sans-serif'):
#G = nx.Graph()
dg = nx.DiGraph()
edges = []
np_amat = np.asarray(bnlearn.amat(r_graph))
for ri in range(np_amat.shape[0]):
for ci in range(np_amat.shape[1]):
if np_amat[ri, ci] == 1:
#G.add_edge(cols_names[ri],cols_names[ci])
dg.add_edge(cols_names[ri], cols_names[ci])
edges.append((cols_names[ri], cols_names[ci]))
#import pdb;pdb.set_trace()
if simple:
if graph_layout == 'spectral':
nx.draw_spectral(dg, font_size=node_text_size)
elif graph_layout == 'random':
nx.draw_random(dg, font_size=node_text_size)
elif graph_layout == 'circular':
nx.draw_circular(dg, font_size=node_text_size)
elif graph_layout == 'spring':
nx.draw_spring(dg, font_size=node_text_size)
else:
nx.draw(dg, font_size=node_text_size)
else:
draw_graph(edges,
directed=True,
labels=labels,
graph_layout=graph_layout,
node_size=node_size,
node_color=node_color,
node_alpha=node_alpha,
node_text_size=node_text_size,
edge_color=edge_color,
edge_alpha=edge_alpha,
edge_tickness=edge_tickness,
edge_text_pos=edge_text_pos,
text_font=text_font)
def test_draw(self):
N=self.G
nx.draw_spring(N)
plt.savefig("test.ps")
nx.draw_random(N)
plt.savefig("test.ps")
nx.draw_circular(N)
plt.savefig("test.ps")
nx.draw_spectral(N)
plt.savefig("test.ps")
nx.draw_spring(N.to_directed())
plt.savefig("test.ps")
os.unlink('test.ps')
def main():
graph = FBGraph(auth)
data = graph.get_friends()
for line in data:
print line
friends = graph.make_friends(data)
graph.add_friend_nodes(friends)
graph.add_likes(friends)
friend_graph = graph.get_friend_graph()
print '\n'
print nx.clustering(friend_graph)
print '\n'
for edge in sorted(friend_graph.edges(data=True), key= lambda x: -1*x[2].get('weight', 1)):
print edge
nx.draw_random(friend_graph)
def crearRed(self):
mensajes = self.moduloPersistencia.getReplicasSeguimiento(self.identificador)
nodos = set()
relaciones = set()
for k in mensajes:
nodos.add(k["id_str"])
nodos.add(k["in_reply_to_status_id"])
relaciones.add((k["id_str"], k["in_reply_to_status_id"]))
print(nodos)
print(relaciones)
grafo = nx.Graph()
grafo.add_nodes_from(nodos)
grafo.add_edges_from(relaciones)
print(nx.info(grafo))
nx.draw_random(grafo)
plt.savefig("red.png")
def test_draw(self):
try:
N = self.G
nx.draw_spring(N)
plt.savefig('test.ps')
nx.draw_random(N)
plt.savefig('test.ps')
nx.draw_circular(N)
plt.savefig('test.ps')
nx.draw_spectral(N)
plt.savefig('test.ps')
nx.draw_spring(N.to_directed())
plt.savefig('test.ps')
finally:
try:
os.unlink('test.ps')
except OSError:
pass
def print_undirected_graph_nx(vertices, edges, name, draw_spring=False):
G=nx.Graph()
for v in vertices:
G.add_node(v)
for v in vertices:
for e in edges:
G.add_edge(e[0], e[1])
if not draw_spring:
nx.draw(G, with_labels=True, node_color='y')
else:
nx.draw_random(G, with_labels=True, node_color='y')
#nx.draw_networkx_edge_labels(G,labels)
plt.savefig("%s.png" % name) # save as png
#plt.show()
plt.clf()
def draw_all(graph):
""" Draw all different layout types for graph """
nx.draw(graph)
plt.savefig(path + 'draw.png')
plt.close()
nx.draw_circular(graph)
plt.savefig(path + 'draw_circular.png')
plt.close()
nx.draw_random(graph)
plt.savefig(path + 'draw_random.png')
plt.close()
nx.draw_spectral(graph)
plt.savefig(path + 'draw_spectral.png')
plt.close()
nx.draw_spring(graph)
plt.savefig(path + 'draw_spring.png')
plt.close()
nx.draw_shell(graph)
plt.savefig(path + 'draw_shell.png')
plt.close()
def try_different_layouts(graph):
layout_dir = 'graph_layout'
if not os.path.exists(layout_dir):
os.mkdir('graph_layout')
nx.draw_random(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'rand.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_circular(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'circular.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_spectral(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'spectral.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_networkx(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'networkx.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw(graph, pos=graphviz_layout(graph), with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4,
edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'graphviz.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_shell(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'shell.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
nx.draw_spring(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey')
plt.axis('off')
plt.savefig(layout_dir + os.sep + 'spring.png', bbox_inches='tight', pad_inches=0, transparent=True)
plt.show()
def network_plot(H, random = True, save = False, diff_color = True):
"""
Overview
-----------------
This is used to plot social network graphs
Input
-----------------
H is assumed to be a networkx network graph
if random is False, display mechanism will use default networkx
representation of graph
save designates whether the plot should be saved to file
diff_color designates whether the plot should include different colors
of agents or not
"""
color_array = []
label_dict = {}
for node in H.nodes():
color_array.append(node.get_color())
label_dict[node] = node.get_name()
if random and diff_color:
nx.draw_random(H, node_color = color_array, labels = label_dict)
elif random and not diff_color:
nx.draw_random(H, labels = label_dict)
elif not random and diff_color:
nx.draw(H, node_color = color_array, labels = label_dict)
elif not random and not diff_color:
nx.draw(H, labels = label_dict)
if save:
mpl.pyplot.savefig("social_network_graph.png")
mpl.pyplot.show()
def nx_plot(r_graph, cols_names, simple=True, labels=None, graph_layout='shell',
node_size=1600, node_color='blue', node_alpha=0.3,
node_text_size=12,
edge_color='blue', edge_alpha=0.3, edge_tickness=1,
edge_text_pos=0.3,
text_font='sans-serif'):
#G = nx.Graph()
dg = nx.DiGraph()
edges = []
np_amat = np.asarray(bnlearn.amat(r_graph))
for ri in range(np_amat.shape[0]):
for ci in range(np_amat.shape[1]):
if np_amat[ri,ci] == 1:
#G.add_edge(cols_names[ri],cols_names[ci])
dg.add_edge(cols_names[ri],cols_names[ci])
edges.append((cols_names[ri],cols_names[ci]))
#import pdb;pdb.set_trace()
if simple:
if graph_layout=='spectral':
nx.draw_spectral(dg,font_size=node_text_size)
elif graph_layout=='random':
nx.draw_random(dg,font_size=node_text_size)
elif graph_layout=='circular':
nx.draw_circular(dg,font_size=node_text_size)
elif graph_layout=='spring':
nx.draw_spring(dg,font_size=node_text_size)
else:
nx.draw(dg,font_size=node_text_size)
else:
draw_graph(edges,directed=True, labels=labels, graph_layout=graph_layout,
node_size=node_size, node_color=node_color, node_alpha=node_alpha,
node_text_size=node_text_size,
edge_color=edge_color, edge_alpha=edge_alpha, edge_tickness=edge_tickness,
edge_text_pos=edge_text_pos,
text_font=text_font)
def show_cluster_example(sim_threshold):
g = graph.Graph(simm, 150)
clustersize_clique = [c for c in g.cliques() if len(c) == 8][0]
sg = g.nx_graph.subgraph(clustersize_clique)
nx.draw_circular(sg, alpha=0.8, node_size=2000, node_color='b')
plt.show()
clustersize_star = [c for c in g.star() if len(c) == 10][0]
sg = g.nx_graph.subgraph(clustersize_star)
pos = nx.spring_layout(sg)
nx.draw(sg, alpha=0.8, node_size=2000, node_color='b', pos=pos)
plt.show()
clustersize_string = g.string()[0]
sg = g.nx_graph.subgraph(clustersize_string)
nx.draw_random(sg, alpha=0.8, node_size=2000, node_color='b')
plt.show()
#g = graph.Graph(simm, 600)
clustersize_single_link = []# map(len, g.single_link())
return [sim_threshold, clustersize_clique, clustersize_single_link, clustersize_star, clustersize_string]
gradoTre = grafoTre.degree().values()
numpy.savetxt("../data/DistrGrado_Tre", gradoTre, fmt="%d", newline="\n")
istoGradoTre = networkx.degree_histogram(grafoTre)
numpy.savetxt("../data/IstoGrado_Tre", istoGradoTre, fmt="%d", newline="\n")
treCell["grado"] = gradoTre
treCell.to_csv("../data/Tre_towers.csv")
# In[9]:
get_ipython().magic(u"matplotlib inline")
pyplot.figure(figsize=(16, 9))
pyplot.subplot(222)
networkx.draw_random(grafoTim)
pyplot.subplot(221)
networkx.draw_random(grafoVoda)
pyplot.subplot(223)
networkx.draw_random(grafoWind)
pyplot.subplot(224)
networkx.draw_random(grafoTre)
pyplot.show()
# In[60]:
def test_edge_colors_and_widths(self):
nx.draw_random(self.G, edgelist=[(0, 1), (0, 2)], width=[1, 2], edge_colors=['r', 'b'])
if shared_domains[key] == 0:
print key
else:
if perc_shared_domains[key] > 4.6:#(float(1)/1103)*100: # thresholding
G.add_edge(key[0],key[1],weight=perc_shared_domains[key])#{'weight':perc_shared_domains[key]*100})
#G.add_edge(key[0],key[1],weight=perc_shared_domains[key]) # complete network
vals = sorted([G[n[0]][n[1]]['weight'] for n in G.edges()])
#values = [int(10*(G[n[0]][n[1]]['weight'])) for n in G.edges()] # ?????
jet = cm = plt.get_cmap('jet')
cNorm = colors.Normalize(vmin=vals[0], vmax=vals[-1])
#cNorm = colors.Normalize(vals)
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
colorList = []
for i in range(len([int(G[n[0]][n[1]]['weight']) for n in G.edges()])):
colorVal = scalarMap.to_rgba(vals[i])
# print [G[n[0]][n[1]]['weight'] for n in G.edges()][i]
# print colorVal
colorList.append(colorVal)
deg_dist = []
for n in G.nodes():
deg_dist.append(G.degree(n))
print deg_dist
#print colorList
nx.draw_random(G,edge_color=colorList,font_size="18",font_weight="bold",bbox="m")
plt.show()
def draw(self):
nx.draw_random(self.graph)
plt.show(block=False)
# pass
print "REPLY COUNTS"
print userfreq
print freq
print poi_retweet
print "Mention COUNTS"
#print mentions_count
#print usermentionsfreq
#print poi_mentions
G=nx.DiGraph()
#A=pgv.AGraph()
for edge in edges:
G.add_edge(edge[0],edge[1])
#A.add_edge(edge[0],edge[1])
#A.layout() # layout with default (neato)
#A.draw('simple.png') # draw png
#export so you can use gephi
nx.write_graphml(G,'ed-test-mentions-replies-to.graphml')
nx.write_gexf(G, 'ed-test-mentions-replies-to.gexf')
# nx.draw_spring(G)
# nx.draw_shell(G)
nx.draw_random(G)
plt.show()
print("nxdraw")
nx.draw(graph, node_color=node_color, node_size=node_size)
print("plt save")
plt.savefig("path_full.png")
print("Printing cir picture")
plt.clf()
print("nxdraw")
nx.draw_circular(graph, node_color=node_color, node_size=node_size)
print("plt save")
plt.savefig("path_full_cir.png")
print("Printing rand picture")
plt.clf()
print("nxdraw")
nx.draw_random(graph, node_color=node_color, node_size=node_size)
print("plt save")
plt.savefig("path_full_rand.png")
"""print("Printing spectral picture")
plt.clf()
nx.draw_spectral(graph, node_color=node_color, node_size=node_size)
plt.savefig("path_full_spectral.png")
print("Printing spring picture")
plt.clf()
nx.draw_spring(graph, node_color=node_color, node_size=node_size)
plt.savefig("path_full_spring.png")
print("Printing shell picture")
plt.clf()
def main():
# 1.0 Loading a local data file
# Load the Hartford drug users data, a directed binary graph.
# We will specify that the graph be generated as a directed graph, and
# that the nodes are integers (rather than strings)
hartford=nx.read_edgelist("../../data/hartford_drug.txt",create_using=nx.DiGraph(),nodetype=int)
nx.info(hartford) # Check the the data has been loaded properly
# 2.0 Connecting to a database
# 3.0 Building a network directly from the Internet
# WARNING: This can take a long time to run!
seed="imichaeldotorg" # Set the seed user within livejournal.com
seed_url="http://"+seed+".livejournal.com"
# 3.1 Scrape, parse and build seed's ego net
sg=get_sg(seed_url)
net,newnodes=create_egonet(sg)
nx.write_pajek(net,"../../data/"+seed+"_ego.net") # Save data as Pajek
nx.info(net)
# 3.2 Perform snowball search, where k=2
k=2
for g in range(k):
net,newnodes=snowball_round(net,newnodes)
nx.write_pajek(net,"../../data/"+seed+"_step_"+str(g+1)+".net")
# 4.0 Calculate in-degree centrality for Hartford data
in_cent=nx.in_degree_centrality(hartford)
# 5.0 Calculating multiple measures, and finding
# most central actors
hartford_ud=hartford.to_undirected()
hartford_mc=nx.connected_component_subgraphs(hartford_ud)[0] # First, extract MC
# 5.1 Calculate multiple measures on MC
bet_cen=nx.betweenness_centrality(hartford_mc)
clo_cen=nx.closeness_centrality(hartford_mc)
eig_cen=nx.eigenvector_centrality(hartford_mc)
# 5.2 Find the actors with the highest centrality for each measure,
print("Actor "+str(highest_centrality(bet_cen))+" has the highest Betweenness centrality")
print("Actor "+str(highest_centrality(clo_cen))+" has the highest Closeness centrality")
print("Actor "+str(highest_centrality(eig_cen))+" has the highest Eigenvector centrality")
# 6.0 Calculating degree distribution
ba_net=nx.barabasi_albert_graph(1000,2) # Create a Barabasi-Albert network
# 6.1 NX has a nice built-in function for degree distribution
dh=nx.degree_histogram(ba_net)
# 6.2 Plot using same method as http://networkx.lanl.gov/examples/drawing/degree_histogram.html
pos=nx.spring_layout(ba_net)
P.figure(figsize=(8,8))
P.loglog(dh,'b-',marker='o')
P.title("Degree rank plot (log-log)")
P.ylabel("Degree")
P.xlabel("Frequency")
# 6.4 Draw graph in inset
P.axes([0.45,0.45,0.45,0.45])
P.axis('off')
nx.draw_networkx_nodes(ba_net,pos,node_size=20)
nx.draw_networkx_edges(ba_net,pos,alpha=0.4)
P.savefig("../../images/figures/ba_10000.png")
# 6.0 Finding community structure
clus=nx.clustering(hartford_mc,with_labels=True)
# 6.1 Get counts of nodes membership for each clustering coefficient
unique_clus=list(unique(clus.values()))
clus_counts=zip(map(lambda c: clus.values().count(c),unique_clus),unique_clus)
clus_counts.sort()
clus_counts.reverse()
# 6.2 Create a subgraph from nodes with most frequent clustering coefficient
mode_clus_sg=nx.subgraph(hartford_mc,[(a) for (a,b) in clus.items() if b==clus_counts[0][1]])
P.figure(figsize=(6,6))
nx.draw_spring(mode_clus_sg,with_labels=False,node_size=60,iterations=1000)
P.savefig('../../images/networks/mode_clus_sg.png')
# 7.0 Plot Eigenvector centrality vs. betweeness in matplotlib
centrality_scatter(bet_cen,eig_cen,"../../images/figures/drug_scatter.png",ylab="Eigenvector Centrality",xlab="Betweenness Centrality",title="Hartford Drug Network Key Actor Analysis",reg=True)
# 8.0 Outputting network data
# First, output the data as an adjaceny list
nx.write_adjlist(hartford_mc,"../../data/hartford_mc_adj.txt")
# 8.1 Add metric data to the network object
hartford_mc_met=add_metric(hartford_mc,eig_cen)
print(hartford_mc_met.nodes(data=True)[1:10]) # Check the the data was stored
# 8.2 output data using the Pajak format to save the node attribute data
nx.write_pajek(hartford_mc,"../../data/hartford_mc_metric.net") # NX will automatically add all attibute data to output
# 9.0 Exporting data to a CSV file
csv_data={"Betweeness":bet_cen,"Closeness":clo_cen,"Eigenvector":eig_cen}
# 9.1 After we have all the data in a single dict, we send it to out function
# to export the data as a CSV
csv_exporter(csv_data,"../../data/drug_data.csv")
# 10.0 Visualization basics
# 10.1 Use subplots to draw random and circular layouts
# of drug net side-by-side
fig1=P.figure(figsize=(9,4))
fig1.add_subplot(121)
nx.draw_random(hartford_mc,with_labels=False,node_size=60)
fig1.add_subplot(122)
nx.draw_circular(hartford_mc,with_labels=False,node_size=60)
P.savefig("../../images/networks/rand_circ.png")
# 10.2 Draw spring, spectral layouts
P.figure(figsize=(8,8))
nx.draw_spring(hartford_mc,with_labels=False,node_size=60,iterations=10000)
P.savefig("../../images/networks/spring.png")
P.figure(figsize=(8,8))
nx.draw_spectral(hartford_mc,with_labels=False,node_size=60,iterations=10)
P.savefig("../../images/networks/spectral.png")
# 10.3 Draw shell layout with inner-circle as the 25th percentile
# Eigenvector centrality actors
P.figure(figsize=(8,8))
# Find actors in 25th percentile
max_eig=max([(b) for (a,b) in eig_cen.items()])
s1=[(a) for (a,b) in eig_cen.items() if b>=.25*max_eig]
s2=hartford_mc.nodes()
# setdiff1d is a very useful NumPy function!
s2=list(setdiff1d(s2,s1))
shells=[s1,s2]
# Calculate psotion and draw
shell_pos=nx.shell_layout(hartford_mc,shells)
nx.draw_networkx(hartford_mc,shell_pos,with_labels=False,node_size=60)
P.savefig("../../images/networks/shell.png")
# 11.0 Adding analysis to visualization
P.figure(figsize=(15,15))
P.subplot(111,axisbg="lightgrey")
spring_pos=nx.spring_layout(hartford_mc,iterations=1000)
# 11.1 Use betweeneess centrality for node color intensity
bet_color=bet_cen.items()
bet_color.sort()
bet_color=[(b) for (a,b) in bet_color]
# 11.2 Use Eigenvector centrality to set node size
eig_size=eig_cen.items()
eig_size.sort()
eig_size=[((b)*2000)+20 for (a,b) in eig_size]
# 11.3 Use matplotlib's colormap for node intensity
nx.draw_networkx(hartford_mc,spring_pos,node_color=bet_color,cmap=P.cm.Greens,node_size=eig_size,with_labels=False)
P.savefig("../../images/networks/analysis.png")
# open the participants1 text file and read the file in line by line separated by tabs
with open("participantslist1.txt", "rU") as f:
reader=csv.reader(f, delimiter="\t")
d = list(reader)[1:] # store contents in a 2D array of rows and columns
fileindex=0
i=0
while fileindex < len(d):
count=int(d[fileindex][0])
for j in range (1, count+1):
graph.add_node(d[fileindex+j][1])
for j in range (1, count+1):
for k in range (j, count+1):
if j!=k:
graph.add_edge(d[fileindex+j][1],d[fileindex+k][1])
i=int(d[fileindex+j][0])
graph[d[fileindex+j][1]][d[fileindex+k][1]]['project']=projects[i]
fileindex=fileindex+count+1
print graph
nx.draw(graph, with_labels=False)
nx.draw_random(graph)
nx.draw_circular(graph)
nx.draw_spectral(graph)
plt.show()
