def g_one_main(n, md, model, to_pickle=True, data_dir='pkls'):
r = dict()
g = gt.price_network(N=n,
m=md,
gamma=1,
directed=False,
seed_graph=gt.complete_graph(N=md + 1))
if model == 'configuration':
gt.random_rewire(g, model='configuration')
r['N'] = n
r['md'] = md
r['model'] = model
try:
r.update(
dict(
n=g.num_vertices(),
m=g.num_edges(),
# l=average_path(g),
# cc=gt.global_clustering(g)
r_a=gt.assortativity(g, 'total'),
rho_a=rank_assortativity(g, method='spearman'),
tau_a=rank_assortativity(g, method='kendall')))
r.update(g_centrality_correlations(g))
except Exception as e:
logger.error(e)
if to_pickle is True:
filename = gen_filename(n, md, model, data_dir)
with open(filename, 'wb') as f:
pickle.dump(r, f, -1)
return r
def run_graph_tool(n, niter):
pb = progressbar.ProgressBar(maxval=niter).start()
g = gt.price_network(n, 2, directed=False)
for e in g.edges():
g.add_edge(e.target(), e.source())
g.set_directed(True)
start = time.time()
for i in range(niter):
gt.shortest_distance(g)
pb.update(i)
pb.finish()
end = time.time()
return (start, end)
def generate(self):
g = gt.price_network(self.n, directed=True)
g = super().create_reverse_edges(g)
# The capacity will be defined randomly
capacity = g.new_edge_property("int")
for e in g.edges():
capacity[e] = randint(1, 15)
g.ep.cap = capacity
source = super().get_source(g)
sink = super().get_sink(g)
return g, source, sink
def graph_analyser(min_vertices, max_vertices, step, samples, print_header=False):
metrics = open('./results/metrics.out', 'a')
if print_header:
graph_header(metrics)
metrics.close()
for vertices in range(min_vertices, max_vertices, step):
metrics = open('./results/metrics.out', 'a')
vert_dep_metrics = open(
'./results/' + str(vertices) + '-vertices-metrics.out',
'a'
)
print('for ' + str(vertices) + ':')
vertices_header(vert_dep_metrics)
for i in range(samples):
print('sample: ' + str(i))
# print('er')
# g_name = 'er-' + str(vertices) + '-' + str(i)
# compute_all_metrics(
# erdos_renyi_network(vertices, P),
# g_name,
# metrics,
# vert_dep_metrics
# )
print('ba')
g_name = 'ba-' + str(vertices) + '-' + str(i)
compute_all_metrics(
gt.price_network(vertices, 2, directed=False),
g_name,
metrics,
vert_dep_metrics
)
print('dms')
g_name = 'dms-' + str(vertices) + '-' + str(i)
compute_all_metrics(
dms_network(vertices),
g_name,
metrics,
vert_dep_metrics
)
vert_dep_metrics.close()
metrics.close()
import graph_tool.all as gt
from math import sqrt
import numpy as np
g = gt.price_network(1500)
deg = g.degree_property_map("in")
deg.a = 4 * (np.sqrt(deg.a) * 0.5 + 0.4)
ebet = gt.betweenness(g)[1]
ebet.a /= ebet.a.max() / 10.
eorder = ebet.copy()
eorder.a *= -1
pos = gt.sfdp_layout(g)
control = g.new_edge_property("vector<double>")
for e in g.edges():
d = sqrt(sum((pos[e.source()].a - pos[e.target()].a) ** 2)) / 5
control[e] = [0.3, d, 0.7, d]
gt.graph_draw(g, pos=pos, vertex_size=deg, vertex_fill_color=deg, vorder=deg,
edge_color=ebet, eorder=eorder, edge_pen_width=ebet,
edge_control_points=control # some curvy edges
)
raw_input("Press Enter to Continue")
v_fill = [0.6, 0.6, 0.6, 1]
gt.graph_draw(g, pos=pos, vertex_size=deg, vertex_fill_color=v_fill, vorder=deg,
edge_color=ebet, eorder=eorder, edge_pen_width=ebet,
edge_control_points=control # some curvy edges
)
def generate_graph():
"""
brew tap homebrew/science
brew install graph-tool
"""
from graph_tool.all import price_network, sfdp_layout, graph_draw
from graph_tool.all import dfs_search, DFSVisitor, seed_rng
from numpy.random import seed
class AnnotationVisitor(DFSVisitor):
def __init__(self, pred, dist):
self.pred = pred
self.dist = dist
self.roots = {}
def tree_edge(self, e):
depth = self.dist[e.source()]
if depth == 1:
genre = int(e.source())
if genre not in self.roots:
self.roots[genre] = len(self.roots)
else:
genre = self.pred[e.source()]
self.pred[e.target()] = genre
self.dist[e.target()] = depth + 1
# For run-to-run stability, provide a constant seed:
seed(SEED)
seed_rng(SEED)
print 'Generating graph...'
g = price_network(2000)
print 'Performing layout...'
pos = sfdp_layout(g)
print 'Adding depths...'
dist = g.new_vertex_property("int")
pred = g.new_vertex_property("int64_t")
g.set_directed(False)
visitor = AnnotationVisitor(pred, dist)
dfs_search(g, g.vertex(0), visitor)
print 'Iterating over verts...'
flattened = []
maxp = [-9999, -9999]
minp = [+9999, +9999]
maxd = 0
for v in g.vertices():
root_id = pred.a[v]
if root_id not in visitor.roots:
continue
x, y, z = pos[v].a[0], pos[v].a[1], visitor.roots[root_id]
minp[0] = min(minp[0], x)
minp[1] = min(minp[1], y)
maxp[0] = max(maxp[0], x)
maxp[1] = max(maxp[1], y)
maxd = max(maxd, dist.a[v])
flattened += [x, y, z]
print 'max depth is', maxd
print 'nroots is', len(visitor.roots)
print 'ncolors is', len(COLORS)
extent = (maxp[0] - minp[0], maxp[1] - minp[1])
padding = extent[0] * PADDING_FRACTION
minp[0] -= padding
minp[1] -= padding
maxp[0] += padding
maxp[1] += padding
scale = [
1.0 / (maxp[0] - minp[0]),
1.0 / (maxp[1] - minp[1])]
scale = min(scale[0], scale[1])
midp = [
0.5 * (maxp[0] + minp[0]),
0.5 * (maxp[1] + minp[1])]
flatarray = []
for v in g.vertices():
root_id = pred.a[v]
if root_id not in visitor.roots:
continue
x, y, root = pos[v].a[0], pos[v].a[1], visitor.roots[root_id]
x = (0.5 + (x - midp[0]) * scale)
y = (0.5 + (y - midp[1]) * scale)
prom = int(dist.a[v])
flatarray += [x, y, root, prom]
return flatarray
import graph_tool.all as gt
import numpy as np
g = gt.price_network(2000)
deg = g.degree_property_map("in")
deg.a = 4 * (np.sqrt(deg.a) * 0.5 + 0.4)
ebet = gt.betweenness(g)[1]
ebet.a /= ebet.a.max() / 10.
eorder = ebet.copy()
eorder.a *= -1
pos = gt.sfdp_layout(g)
gt.graph_draw(g, pos=pos, vertex_size=deg, vertex_fill_color=deg, vorder=deg, edge_color=ebet, eorder=eorder, edge_pen_width=ebet, output="output1.svg")
def generate_graph():
"""
brew tap homebrew/science
brew install graph-tool
"""
from graph_tool.all import price_network, sfdp_layout, graph_draw
from graph_tool.all import dfs_search, DFSVisitor, seed_rng
from numpy.random import seed
class AnnotationVisitor(DFSVisitor):
def __init__(self, pred, dist):
self.pred = pred
self.dist = dist
self.roots = {}
def tree_edge(self, e):
depth = self.dist[e.source()]
if depth == 1:
genre = int(e.source())
if genre not in self.roots:
self.roots[genre] = len(self.roots)
else:
genre = self.pred[e.source()]
self.pred[e.target()] = genre
self.dist[e.target()] = depth + 1
# For run-to-run stability, provide a constant seed:
seed(SEED)
seed_rng(SEED)
print 'Generating graph...'
g = price_network(2000)
print 'Performing layout...'
pos = sfdp_layout(g)
print 'Adding depths...'
dist = g.new_vertex_property("int")
pred = g.new_vertex_property("int64_t")
g.set_directed(False)
visitor = AnnotationVisitor(pred, dist)
dfs_search(g, g.vertex(0), visitor)
print 'Iterating over verts...'
flattened = []
maxp = [-9999, -9999]
minp = [+9999, +9999]
maxd = 0
for v in g.vertices():
root_id = pred.a[v]
if root_id not in visitor.roots:
continue
x, y, z = pos[v].a[0], pos[v].a[1], visitor.roots[root_id]
minp[0] = min(minp[0], x)
minp[1] = min(minp[1], y)
maxp[0] = max(maxp[0], x)
maxp[1] = max(maxp[1], y)
maxd = max(maxd, dist.a[v])
flattened += [x, y, z]
print 'max depth is', maxd
print 'nroots is', len(visitor.roots)
print 'ncolors is', len(COLORS)
extent = (maxp[0] - minp[0], maxp[1] - minp[1])
padding = extent[0] * PADDING_FRACTION
minp[0] -= padding
minp[1] -= padding
maxp[0] += padding
maxp[1] += padding
scale = [1.0 / (maxp[0] - minp[0]), 1.0 / (maxp[1] - minp[1])]
scale = min(scale[0], scale[1])
midp = [0.5 * (maxp[0] + minp[0]), 0.5 * (maxp[1] + minp[1])]
flatarray = []
for v in g.vertices():
root_id = pred.a[v]
if root_id not in visitor.roots:
continue
x, y, root = pos[v].a[0], pos[v].a[1], visitor.roots[root_id]
x = (0.5 + (x - midp[0]) * scale)
y = (0.5 + (y - midp[1]) * scale)
prom = int(dist.a[v])
flatarray += [x, y, root, prom]
return flatarray