def main():
graf1 = nx.connected_watts_strogatz_graph(5, 4, 0.5, seed=1)
graf2 = nx.connected_watts_strogatz_graph(50, 20, 0.5, seed=1)
graf3 = nx.connected_watts_strogatz_graph(1000, 50, 0.5, seed=1)
graph = nx.to_dict_of_lists(graf3)
g = nx.Graph(graph)
start = timeit.default_timer()
print("Vertex cover: ", greedy(graph, g))
stop = timeit.default_timer()
print('Time: ', stop - start)
def test_omega():
Gl = nx.connected_watts_strogatz_graph(50, 6, 0, seed=rng)
Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
omegal = omega(Gl, niter=1, nrand=1, seed=rng)
omegar = omega(Gr, niter=1, nrand=1, seed=rng)
omegas = omega(Gs, niter=1, nrand=1, seed=rng)
print("omegas, omegal, omegar")
print(omegas, omegal, omegar)
assert_true(omegal < omegas and omegas < omegar)
def main():
graf1 = nx.connected_watts_strogatz_graph(5, 4, 0.5, seed=1)
graf2 = nx.connected_watts_strogatz_graph(50, 20, 0.5, seed=1)
graf3 = nx.connected_watts_strogatz_graph(1000, 50, 0.5, seed=1)
graph = nx.to_dict_of_lists(graf3)
g = nx.Graph(graph)
start = timeit.default_timer()
print("Vertex cover: ", approx_vertex_cover(graph))
stop = timeit.default_timer()
print('Time: ', stop - start)
nx.draw(g, with_labels=True)
plt.show()
def __init__(self, n, seed):
if seed == 0:
# 空网络
self.net = nx.empty_graph()
elif seed == 1:
# ER随机图
self.net = nx.gnp_random_graph(n, 0.012)
elif seed == 2:
# ER随机图
self.net = nx.gnp_random_graph(n, 0.1)
elif seed == 3:
# ER随机图
self.net = nx.gnp_random_graph(n, 0.3)
elif seed == 4:
# 规则图
self.net = nx.watts_strogatz_graph(n, 4, 0)
elif seed == 5:
# 规则图
self.net = nx.watts_strogatz_graph(n, 8, 0)
elif seed == 6:
# 规则图
self.net = nx.watts_strogatz_graph(n, 16, 0)
elif seed == 7:
# WS小世界网络
self.net = nx.connected_watts_strogatz_graph(n, 4, 0.1)
elif seed == 8:
# WS小世界网络
self.net = nx.connected_watts_strogatz_graph(n, 8, 0.1)
elif seed == 9:
# WS小世界网络
self.net = nx.connected_watts_strogatz_graph(n, 16, 0.1)
elif seed == 10:
# 无标度网络
self.net = nx.barabasi_albert_graph(n, 4)
elif seed == 11:
# 无标度网络
self.net = nx.barabasi_albert_graph(n, 8)
elif seed == 12:
# 无标度网络
self.net = nx.barabasi_albert_graph(n, 16)
elif seed == 13:
# 高斯随机分块网络
self.net = nx.gaussian_random_partition_graph(n, 100, 10, 1, 0.01)
elif seed == 14:
# 高斯随机分块网络
self.net = nx.gaussian_random_partition_graph(n, 100, 10, 1, 0.01)
elif seed == 15:
# 高斯随机分块网络
self.net = nx.gaussian_random_partition_graph(n, 100, 10, 1, 0.01)
else:
self.net = nx.empty_graph()
def random_g(self):
#n é o numero de vertices
n = self.quant_vert
print(n)
G = nx.connected_watts_strogatz_graph(n, randint(int(n / 2), n - 1),
0.5, 100, randint(1, 100))
# a é uma lista contendo as arestas do grafo
a = G.edges()
#matriz de adj do grafo
self.matriz = []
for i in range(n):
self.matriz.append([0] * n)
#plotagem do peso gerado aletoriamente na matriz
for v1, v2 in a:
n = randint(1, 50)
self.matriz[v1][v2] = n
self.matriz[v2][v1] = n
#atribuição do peso no grafo
G.edges[v1, v2]['weight'] = n
self.quant_vert = G.number_of_nodes()
#G.edges[v1,v2]['weight']=n
return G
def make_graph(graph_params,
eta,
require_connected=True,
require_invertible=True,
require_stationary=True):
while True:
strongly_connected = False
invertible = False
stationary = False
graph = nx.connected_watts_strogatz_graph(**graph_params)
g_mat = update_matrix(graph, eta)
strongly_connected = nx.is_connected(graph)
invertible = not (np.linalg.det(g_mat) == 0)
e_vals, e_vects = np.linalg.eig(g_mat)
stationary = (max(e_vals) < 1.0)
if (((not require_connected) or strongly_connected)
and ((not require_invertible) or invertible)
and ((not require_stationary) or stationary)):
break
return graph
def generate_graph(n, k, p, seed):
G = nx.connected_watts_strogatz_graph(n, k, p, seed)
data = json_graph.node_link_data(G)
with open('./Working/graph.json', 'w') as f:
json.dump(data, f)
with open('./Working/graph_flag', mode='w', encoding='utf-8') as fh:
fh.write("i look at you")
def reset_graph(self):
self.graph = nx.connected_watts_strogatz_graph(self.n_node, self.k_ring, self.p_rewiring)
self.edgelabel = -np.ones([self.n_node, self.n_node]).astype('int32')
for i in range(self.n_node):
rndidx = np.random.permutation(len(self.graph.neighbors(i)))
for idx, j in enumerate(self.graph.neighbors(i)):
self.edgelabel[i][j] = rndidx[idx]
def generate_connection_graph(graph_type, params, count):
lower_type = graph_type.lower()
if lower_type == 'complete':
assert (len(params) == 0)
return networkx.complete_graph(count)
elif lower_type == 'complete-bipartite':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
n1 = int(round(count * float(params[0]) / float(params[1])))
n2 = int(round(count * float(params[1]) / float(params[0])))
n1 = 1 if n1 < 1 else n1
n2 = 1 if n2 < 1 else n2
return networkx.complete_bipartite_graph(n1, n2)
elif lower_type == 'circular-ladder':
assert (len(params) == 0)
return networkx.circular_ladder_graph(count)
elif lower_type == 'cycle':
assert (len(params) == 0)
return networkx.cycle_graph(count)
elif lower_type == 'periodic-2grid':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
width = int(round(math.sqrt(count * float(params[0]) / float(params[1]))))
height = int(round(math.sqrt(count * float(params[1]) / float(params[0]))))
width = 1 if width < 1 else width
height = 1 if height < 1 else height
return networkx.grid_2d_graph(width, height, True)
elif lower_type == 'nonperiodic-2grid':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
width = int(round(math.sqrt(count * float(params[0]) / float(params[1]))))
height = int(round(math.sqrt(count * float(params[1]) / float(params[0]))))
width = 1 if width < 1 else width
height = 1 if height < 1 else height
return networkx.grid_2d_graph(width, height, False)
elif lower_type == 'hypercube':
assert (len(params) == 0)
return networkx.hypercube_graph(int(round(math.log(count, 2))))
elif lower_type == 'star':
assert (len(params) == 0)
return networkx.star_graph(count - 1)
elif lower_type == 'wheel':
assert (len(params) == 0)
return networkx.wheel_graph(count)
elif lower_type == 'erdos-reyni':
assert (len(params) == 1)
return networkx.erdos_renyi_graph(count, float(params[0]))
elif lower_type == 'watts-strogatz':
assert (len(params) == 2)
if int(params[0]) >= count / 2:
k = int(count / 2 - 1)
else:
k = int(params[0])
return networkx.connected_watts_strogatz_graph(count, k, int(params[1]))
else:
print "Unknown graph type {}".format(lower_type)
assert False
def generate_graphs_with_constraints(n=100, k=2, m=2):
if m < k:
raise Exception(
'm (number of constraints) less than k (number of clusters)')
# G = nx.gnp_random_graph(n, math.pow(math.log(n),1.5)/n) #erdos renyi graph that is probably connected
# G = nx.powerlaw_cluster_graph(n,int(np.log(n)), 3.0/int(np.log(n)) )
G = nx.connected_watts_strogatz_graph(n,
k=5,
p=1.25 * np.log(n) / n,
tries=100,
seed=None)
G = nx.convert_node_labels_to_integers(
max(nx.connected_component_subgraphs(G),
key=len)) #returns largest connected component
constraints = {}
for i, x in enumerate(
np.random.choice(nx.number_of_nodes(G), size=m, replace=False)):
if i < k:
constraints[x] = i
else:
constraints[x] = np.random.randint(k)
for (u, v) in G.edges():
weight = np.random.rand()
G.edge[u][v]['weight'] = weight
G.edge[v][u]['weight'] = weight
#make constraint edges full connected:
# for con in constraints:
# for v in G.nodes():
# if con!=v:
# if np.random.rand() < 1:
# G.add_edge(con, v,{'weight':1})
return G, constraints
def gen_graph(num_min, num_max, g_type, path, i, n_type='uniform'):
cur_n = random.randint(num_max - num_min + 1) + num_min
if g_type == 'erdos_renyi':
g = nx.erdos_renyi_graph(n=cur_n, p=0.15)
elif g_type == 'powerlaw':
g = nx.powerlaw_cluster_graph(n=cur_n, m=4, p=0.05)
elif g_type == 'small-world':
g = nx.connected_watts_strogatz_graph(n=cur_n, k=8, p=0.1)
elif g_type == 'barabasi_albert':
g = nx.barabasi_albert_graph(n=cur_n, m=4)
if n_type != 'uniform':
if n_type == 'random':
weights = {}
for node in g.nodes():
weights[node] = random.uniform(0, 1)
else:
degree = nx.degree_centrality(g)
maxDegree = max(dict(degree).values())
weights = {}
for node in g.nodes():
weights[node] = degree[node] / maxDegree
nx.set_node_attributes(g, weights, 'weight')
path = '%s/%s-%s' % (path, str(num_min), str(num_max))
if not os.path.exists(path):
os.mkdir(path)
nx.write_gml(g, '%s/g_%s' % (path, str(i)))
def __init__(self,
in_channel,
out_channel,
n=32,
k=4,
p=0.75,
m=1,
stride=2,
wire_def=None,
graph_mode='ws',
is_training=True,
name=None):
self.in_channel = in_channel
self.out_channel = out_channel
self.stride = stride
self.is_training = is_training
self.name = name
if wire_def is not None:
tf.logging.info('Load graph from {}'.format(wire_def))
self.G = nx.read_adjlist(wire_def,
create_using=nx.DiGraph(),
nodetype=int)
else:
if graph_mode == 'ws':
self.G = nx.connected_watts_strogatz_graph(n, k, p)
elif graph_mode == 'er':
self.G = nx.erdos_renyi_graph(n, p, directed=True)
elif graph_mode == 'ba':
self.G = nx.barabasi_albert_graph(n, m)
self.G = nx.DiGraph(self.G.edges)
self.rev_G = self.G.reverse()
def createGraph(gtype, n, p, ppitype):
if (gtype == 'ER'):
return nx.erdos_renyi_graph(n, p)
elif (gtype == 'BA'):
return nx.barabasi_albert_graph(n, int(p * n))
elif (gtype == 'WS'):
return nx.connected_watts_strogatz_graph(n, 8, p)
elif (gtype == 'GEO'):
return graphGen.geoGraphP(n, 3, p)
elif (gtype == 'VZ'):
# Vazquez recommends p = 0.1, q = 0.7
# Gibson suggests p = 0.24, q = 0.887
qmap = {0.1: 0.7, 0.24: 0.887}
assert (p in qmap.keys())
return graphGen.VazquezGraph(n, p, qmap[p])
elif (gtype == 'EV'):
qmap = {0.1: 0.7, 0.24: 0.887}
assert (p in qmap.keys())
return graphGen.EVGraph(n, p, qmap[p], n // 5, 0.8)
elif (gtype == 'SL'):
# values from Sole paper
return graphGen.SoleGraph(n, 0.53, 0.06)
elif (gtype == 'PPI'):
return ppiGen.ppiGraph(n, ppitype)
else:
raise ValueError('Invalid graph type')
def load():
parser = argparse.ArgumentParser()
parser.add_argument("-p",
"--dump-pcap",
help="Dumps pcap of traffic to stdout",
action="store_true")
parser.add_argument("-i", "--input-file", help="JSON input file")
parser.add_argument(
"-n",
"--number",
help="Number of nodes to generate (if no input file is given)",
type=int,
default=5)
parser.add_argument(
"-c",
"--connectedness",
help=
"Connectedness [0.2, 1.0) of the network (if now input file is given)",
type=float,
default=0.75)
args = parser.parse_args()
if (args.input_file):
mesh = load_mesh(args.input_file)
else:
mesh = nx.connected_watts_strogatz_graph(
args.number, int(args.number * args.connectedness),
args.connectedness)
return mesh, args
def generate_patches_2d_small_world(self):
# I will generate a small world network graph using this tool from networkx
# the problem is that I need a graph with Patch nodes while this gives me a graph
# with tuple nodes, so I need to make a conversion
sw_graph = nx.connected_watts_strogatz_graph(self.nr_patches, int(math.sqrt(self.nr_patches)), .1)
# will use this dict to later build the edges in my new graph
sw_patches = {}
i = 0
for sw_node in sw_graph.nodes():
i += 1
patch = self.generate_patch(id=i, pos=sw_node)
sw_patches[sw_node] = patch
self.graph.add_node(patch)
self.patches.append(patch)
# now build the edges in our graph using the small world graph (sw_graph)
for sw_node, patch in sw_patches.items():
for sw_friend in sw_graph[sw_node]:
friend_patch = sw_patches[sw_friend]
self.graph.add_edge(patch, friend_patch)
# now we need to generate the positions of the nodes on the image
positions = nx.spring_layout(self.graph, scale=100)
for node in self.graph:
node.pos = positions[node]
self.set_node_degrees()
def __init__(self, upper=1, mu=1/2, sigma=np.sqrt(1/2) / 2, thresh=0.95, prob_adopted=0.5, neighbor_threshold=5/100, sim_thresh=0.15, product_adoption_jitter=np.sqrt(1/2) / 12, n_init=20, path='runs/'):
self.lower = 0
self.upper = upper
self.mu = mu
self.sigma = sigma
self.thresh = thresh
self.prob_adopted = prob_adopted
self.neighbor_threshold = neighbor_threshold
self.sim_thresh = sim_thresh
self.product_adoption_jitter = product_adoption_jitter
self.product_dist = stats.truncnorm((self.lower - self.mu)/self.sigma, (self.upper - self.mu)/self.sigma, loc=self.mu, scale=self.sigma)
self.n_init = n_init
self.path = path
self.ims = []
if not os.path.exists(self.path + 'graphs/'):
os.makedirs(self.path + 'graphs/')
if not os.path.exists(self.path + 'frames/'):
os.makedirs(self.path + 'frames/')
if not os.path.exists(self.path + 'gifs/'):
os.makedirs(self.path + 'gifs/')
self.G = nx.connected_watts_strogatz_graph(self.n_init, 3, np.random.rand())
products = dict([(i, self.random_product()) for i in range(self.n_init)])
thresholds = dict([(i, np.random.rand()) for i in range(self.n_init)])
schellings = dict([(i, self.random_schelling()) for i in range(self.n_init)])
nx.set_node_attributes(self.G, products, 'apt_markakis')
nx.set_node_attributes(self.G, thresholds, 'threshold')
nx.set_node_attributes(self.G, schellings, 'schelling')
nx.write_graphml(self.G, self.path + 'graphs/m0.graphml')
def generate_multi_level_graph(n, w_min, w_max, levels, graph_type, params):
graph = None
if graph_type == "watts-strogatz":
graph = nx.connected_watts_strogatz_graph(n, params['neighbors'],
params['prob'],
params['tries'])
elif graph_type == "erdos-renyi":
graph = nx.erdos_renyi_graph(n, params['prob'], params['seed'])
elif graph_type == "barabasi-albert":
graph = nx.barabasi_albert_graph(n, params['m'])
terminal_sets = list()
num_nodes = len(list(graph.nodes))
num_edges = len(list(graph.edges))
print('Graph generated has ' + str(num_nodes) + ' nodes and ' +
str(num_edges))
for node in list(graph.nodes):
graph.nodes[node]['weight'] = random.randint(w_min, w_max)
terminals = list(graph.nodes)
for i in range(levels):
num_n = int((num_nodes * 0.2) / (i + 2))
terminals = random.sample(terminals, num_n)
terminals.sort()
terminal_sets.append(terminals)
terminal_sets.reverse()
for i in range(levels):
print('Level ' + str(i) + ' has ' + str(len(terminal_sets[i])) +
' terminals')
return graph, terminal_sets
def smallworld(n, rewire=0.3, seed=35):
"""Return a watts-strogatz small world graph.
Mimics the layout of smallworld_topo.SmallWorldTopology.
"""
graph = nx.connected_watts_strogatz_graph(n, min(4, n/3), rewire, seed=seed)
return from_graph(graph)
def genNet(n, k=4, pRewire=.1, type='grid'): # create net if type == 'grid': #wrap the grid net = nx.grid_2d_graph(int(n**.5), int(n**.5), periodic=True) #net = nx.grid_2d_graph(3, 3, periodic=True) #net = nx.grid_2d_graph(2, 2, periodic=False) #plotNet(net) #print(len(net.edges())) #assert(0) # rewire numRewired = 0 #while numRewired < (pRewire * nx.number_of_nodes(net)): while numRewired < 1: tries = 0 while tries < 100: tries = tries + 1 #print([numRewired, pRewire * nx.number_of_nodes(net), tries]) v1 = random.choice(net.nodes()) v2 = random.choice(net.nodes()) if not( net.has_edge(v1,v2) or v1==v2 or len(net.neighbors(v1)) <= 1): #net.neighbors is sometimes (often?) a blank set, changed so v1 needs 2 nb #print net.neighbors(v1) break v1Neighbors = net.neighbors(v1) #print v1Neighbors #print v1 #print v2 #print(len(net.edges())) tobeDeleted = random.choice(v1Neighbors) net.remove_edge(v1, tobeDeleted) #print(len(net.edges())) #print([v1, tobeDeleted, v2]) net.add_edge(v1, v2) numRewired = numRewired + 1 #plotNet(net) #assert(0) return net, nx.to_numpy_matrix(net, dtype=np.float) elif type == 'smallworld': #net = nx.connected_watts_strogatz_graph(n, k, .15) net = nx.connected_watts_strogatz_graph(n, k, pRewire) return net, nx.to_numpy_matrix(net, dtype=np.float) elif type == 'pref': net = nx.barabasi_albert_graph(n, 2) return net, nx.to_numpy_matrix(net, dtype=np.float) elif type == 'ER': #net = nx.erdos_renyi_graph(n, .006) targetDegree = 4. nEdgesPossible = ((n*n)-n)/2. pEdge = (n * targetDegree) / (2. * nEdgesPossible) assert(pEdge <= 1) # spare networks will likely be disconnected, so try a bunch tries = 100 while tries > 0: net = nx.erdos_renyi_graph(n, pEdge) if nx.number_connected_components(net) > 1: tries = tries - 1 else: break return net, nx.to_numpy_matrix(net, dtype=np.float)
def test_ws_clustering():
N = 1000
k = 8
ps = np.linspace(0, 1, 20)
n_trials = 40
p_to_Gs = {
p:
[nx.connected_watts_strogatz_graph(N, k, p) for _ in range(n_trials)]
for p in ps
}
expected_clusterings = []
actual_clusterings = []
for p, Gs in p_to_Gs.items():
expected_clusterings.append(ws_clustering(k, p))
actual_clusterings.append([nx.average_clustering(G) for G in Gs])
quartiles = np.quantile(actual_clusterings, (.25, .75),
axis=1,
interpolation='midpoint')
mean_actual = np.mean(actual_clusterings, axis=1)
name = f'Comparison of Clustering Estimation vs Reality\nk={k}'
plt.title(name)
plt.plot(ps, expected_clusterings)
plt.plot(ps, mean_actual)
plt.fill_between(ps, quartiles[0], quartiles[1], alpha=.4, color='orange')
plt.legend(('Expected', f'Actual (Avg over {n_trials} trials)'))
plt.xlabel('p')
plt.ylabel('Clustering')
plt.savefig(name.replace('\n', ' ') + '.png', format='png')
def gerar_grafo(num_vertices):
G = nx.connected_watts_strogatz_graph(num_vertices,25, 0.5)
#G = nx.complete_graph(num_vertices)
a = G.edges()
matriz = []
for i in range(num_vertices):
matriz.append([0]*num_vertices)
for v1,v2 in a:
n = random.randint(10,100)
matriz[v1][v2] = n
matriz[v2][v1] = n
#atribuição do peso no grafo
G.edges[v1,v2]['weight']=n
k = kr()
A = prim.Graph(num_vertices)
A.graph = matriz
mst = k.kruskal(G)
mst_prim = A.primMST()
plt.show()
nx.draw(G,node_size=5,alpha=1,node_color="black", edge_color = "#1880C7", with_labels=False)
plt.axis('equal')
plt.savefig('Grafo.png')
plt.show()
plt.figure(figsize=(8,8))
nx.draw(mst_prim,node_size=5,alpha=1,node_color="black", edge_color = "#1880C7", with_labels=False)
plt.axis('equal')
plt.savefig('mst_prim.png')
plt.show()
nx.draw(mst,node_size=5,alpha=1,node_color="black", edge_color = "#1880C7", with_labels=False)
plt.axis('equal')
plt.savefig('mst_kruskal.png')
plt.show()
def create_graph(self, params):
# case statements on type of graph
if self.type == 'small_world':
self.graph = nx.watts_strogatz_graph(
int(params[0]), int(params[1]), float(params[2]),
None if len(params) < 4 else int(params[3]))
cg.SWC += 1
self.idx = cg.SWC
self.path = 'smallWorldGraphs'
elif self.type == 'small_world_connected':
self.graph = nx.connected_watts_strogatz_graph(
int(params[0]), int(params[1]), float(params[2]),
100 if len(params) < 4 else int(params[3]),
None if len(params) < 5 else int(params[4]))
cg.SWCC += 1
self.idx = cg.SWCC
self.path = 'smallWorldConnectedGraphs'
elif self.type == 'small_world_newman':
self.graph = nx.newman_watts_strogatz_graph(
int(params[0]), int(params[1]), float(params[2]),
None if len(params) < 4 else int(params[3]))
cg.SWNC += 1
self.idx = cg.SWNC
self.path = 'smallWorldNewmanGraphs'
elif self.type == 'power_law':
self.graph = nx.powerlaw_cluster_graph(
int(params[0]), int(params[1]), float(params[2]),
None if len(params) < 4 else int(params[3]))
cg.PLC += 1
self.idx = cg.PLC
self.path = 'powerLawGraphs'
elif self.type == 'power_law_tree':
self.graph = nx.random_powerlaw_tree(
int(params[0]), 3 if len(params) < 2 else float(params[1]),
None if len(params) < 3 else int(params[2]),
100 if len(params) < 4 else int(params[3]))
cg.PLTC += 1
self.idx = cg.PLTC
self.path = 'powerLawTreeGraphs'
elif self.type == 'random_graph':
self.graph = nx.gnm_random_graph(
int(params[0]), int(params[1]),
None if len(params) < 3 else int(params[2]),
False if len(params) < 4 else bool(params[3]))
cg.RGC += 1
self.idx = cg.RGC
self.path = 'randomGraphs'
elif self.type == 'erdos_renyi_random':
self.graph = nx.erdos_renyi_graph(
int(params[0]), float(params[1]),
None if len(params) < 3 else int(params[2]),
False if len(params) < 4 else bool(params[3]))
cg.ERRC += 1
self.idx = cg.ERRC
self.path = 'erdosRenyiRandomGraphs'
else:
print 'GRAPH TYPE:', self.type
raise Exception('Invalid Type of Graph input into argv[2]')
def __init__(self, M, fully_connected=False):
# M: Number of nodes.
self._num_nodes = M
if fully_connected:
self._graph = nx.complete_graph(M)
else:
self._graph = nx.connected_watts_strogatz_graph(M, 3, 0.6)
def genG(n,k,p,tries=1000, seed=None, graphtype="sw"):
if graphtype=="sw":
g=nx.connected_watts_strogatz_graph(n,k,p,tries,seed) # networkx graph
random.seed(randomseed) # bug in nx, random seed needs to be reset
a=np.array(nx.adjacency_matrix(g).todense()) # adjacency matrix
else: # erdos-renyi... TODO fix up
g=nx.erdos_renyi_graph(n,p)
return g, np.array(a, dtype=np.int32)
def generate_SM_graph_with_trust(N, p, k, trust_list, filename):
N_VALS = len(trust_list)
G = nx.connected_watts_strogatz_graph(N, k, p)
for (u, v) in G.edges_iter():
val = random.randint(0, N_VALS - 1)
G.edge[u][v]['t'] = trust_list[val]
nx.write_edgelist(G, filename, '#', '\t', True, 'utf-8')
def generate_SM_graph_with_trust(N, p, k, trust_list, filename):
N_VALS = len(trust_list)
G = nx.connected_watts_strogatz_graph(N, k, p)
for (u,v) in G.edges_iter():
val = random.randint(0,N_VALS-1)
G.edge[u][v]['t'] = trust_list[val]
nx.write_edgelist(G, filename, '#', '\t', True, 'utf-8')
def setup(
network='random', # ['complete', 'random', 'Watts-Strogatz', 'connected caveman', 'Barabasi-Albert']
n_agents=40, # number of agents
deg=4, # number of connections for each agent
n_beliefs=25, # number of knowledge graph elements each agent has
n_concepts=30):
"""
Generates the initial conditions of the simulation
Returns
-------
g: networkx graph
primary graph represents the semantic network,
each individual (node) has an attribute 'M' representing their semantic network
all_beliefs: an array of tuples, which represents all edges anywhere in the semantic
network network of any individual. Does not include edges that could be part of the
semantic network (because they are present in a complete graph with `n_concepts`,
but were not selected).
"""
np.random.seed()
connected = False
while not connected:
if network == 'complete':
g = nx.complete_graph(n=n_agents)
elif network == 'random':
g = nx.gnm_random_graph(n=n_agents, m=int(n_agents * deg / 2))
elif network == 'random regular':
g = nx.random_regular_graph(d=deg, n=n_agents)
elif network == 'Watts-Strogatz':
g = nx.connected_watts_strogatz_graph(n=n_agents, k=deg,
p=.02) # valid for even deg
elif network == 'connected caveman':
g = nx.connected_caveman_graph(l=int(n_agents / deg), k=deg + 1)
elif network == 'Barabasi-Albert':
g = nx.barabasi_albert_graph(n=n_agents, m=int(
deg /
2)) # approximates deg for large n_agents, when deg is even.
else:
raise ValueError('%s is not a valid network name' % network)
connected = nx.is_connected(g)
# give starting information
nx.set_node_attributes(
g,
name='M', # M for mind
values={i: nx.gnm_random_graph(n_concepts, n_beliefs)
for i in g})
beliefs = np.unique([
tuple(sorted(belief)) for agent in g
for belief in g.nodes[agent]['M'].edges()
],
axis=0)
return g, beliefs
def compute_random_graph(nodes, edges, g):
degrees = sum(g.degree().values())
avg_degree = (float(degrees) / float(nodes))
try:
return nx.connected_watts_strogatz_graph(nodes, int(avg_degree), 0.5)
except nx.NetworkXPointlessConcept:
assert (edges == (nodes - 1))
return g
def generate_small_world_graph(output_dir, n_nodes, k_neighbors, p_edge_modify, seed=123, feature_dim=None):
graph = nx.connected_watts_strogatz_graph(n=n_nodes, k=k_neighbors, p=p_edge_modify, seed=seed)
features = None
if feature_dim is not None:
assert type(feature_dim) == int, "feature_dim must be None or int type"
features = FullySynthetic.random_features((n_nodes, feature_dim))
if output_dir is not None:
FullySynthetic.save_graph(output_dir, graph, features)
return graph, features
def generate_watts_strogatz_graph(n, k, p, seed=123):
g = nx.connected_watts_strogatz_graph(n, k, p, tries=100, seed=seed)
nx.set_edge_attributes(g, None, 'weight')
for u, v, weight in g.edges.data('weight'):
if g[v][u]['weight'] is None:
g[u][v]['weight'] = random.randint(1, 15)
else:
g[u][v]['weight'] = g[v][u]['weight']
return g
def random_graphs():
print("Random graphs")
print("fast GNP random graph")
G = nx.fast_gnp_random_graph(n=9, p=0.4)
draw_graph(G)
print("GNP random graph")
G = nx.gnp_random_graph(n=9, p=0.1)
draw_graph(G)
print("Dense GNM random graph")
G = nx.dense_gnm_random_graph(n=19, m=28)
draw_graph(G)
print("GNM random graph")
G = nx.gnm_random_graph(n=11, m=14)
draw_graph(G)
print("Erdős Rényi graph")
G = nx.erdos_renyi_graph(n=11, p=0.4)
draw_graph(G)
print("Binomial graph")
G = nx.binomial_graph(n=45, p=0.4)
draw_graph(G)
print("Newman Watts Strogatz")
G = nx.newman_watts_strogatz_graph(n=9, k=5, p=0.4)
draw_graph(G)
print("Watts Strogatz")
G = nx.watts_strogatz_graph(n=9, k=2, p=0.4)
draw_graph(G)
print("Watts Strogatz")
G = nx.watts_strogatz_graph(n=9, k=2, p=0.4)
draw_graph(G)
print("Connected Watts Strogatz")
G = nx.connected_watts_strogatz_graph(n=8, k=2, p=0.1)
draw_graph(G)
print("Random Regular Graph")
G = nx.random_regular_graph(d=2, n=9)
draw_graph(G)
print("Barabasi Albert Graph")
G = nx.barabasi_albert_graph(n=10, m=2)
draw_graph(G)
print("Powerlow Cluster Graph")
G = nx.powerlaw_cluster_graph(n=10, m=2, p=0.2)
draw_graph(G)
print("Duplication Divergence Graph")
G = nx.duplication_divergence_graph(n=10, p=0.2)
draw_graph(G)
print("Random lobster Graph")
G = nx.random_lobster(n=10, p1=0.2, p2=0.8)
draw_graph(G)
print("Random shell Graph")
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = nx.random_shell_graph(constructor)
draw_graph(G)
print("Random Powerlow Tree")
G = nx.random_powerlaw_tree(n=24, gamma=3)
draw_graph(G)
print("Random Powerlow Tree Sequence")
G = nx.random_powerlaw_tree(n=13, gamma=3)
draw_graph(G)
def make_connected_WS_graph(self):
self.G = nx.connected_watts_strogatz_graph(self.n, self.k, self.p)
# lam = nx.laplacian_spectrum(G)
# print(nx.adjacency_matrix(G))
# print (number_of_nodes(G))
# (nx.degree(G))
# print(self.G)
self.A = np.array(nx.adjacency_matrix(self.G).todense()) # 隣接行列
self.weight_martix()
def compute_random_graph(nodes, edges, g):
degrees = sum(g.degree().values())
avg_degree = (float(degrees)/float(nodes))
try:
return nx.connected_watts_strogatz_graph(nodes, int(avg_degree), 0.5)
except nx.NetworkXPointlessConcept:
assert (edges == (nodes - 1))
return g
def generate_graph_with_bridges(n, sem):
G = nx.connected_watts_strogatz_graph(n, 4, 0.5)
G2 = nx.connected_watts_strogatz_graph(n, 4, 0.5)
G = nx.disjoint_union(G, G2)
i = 1
for (e1, e2) in G.edges():
G.edges[e1, e2].update(R=random.randint(1, 5), no=i, sem=0)
i += 1
node = random.randint(0, n - 1)
node2 = random.randint(0, n - 1)
while node == node2:
node2 = random.randint(0, n - 1)
G.add_edge(node, 2 * n - 1 - node, R=0, no=i, sem=sem)
G.add_edge(node2,
2 * n - 1 - node2,
R=random.randint(1, 5),
no=i + 1,
sem=0)
return G
def createGraph(gtype, n, p):
if (gtype == 'ER'):
return nx.erdos_renyi_graph(n, p)
elif (gtype == 'BA'):
return nx.barabasi_albert_graph(n, int(p * n))
elif (gtype == 'WS'):
return nx.connected_watts_strogatz_graph(n, 4, p)
elif (gtype == 'GEO'):
return gg.geoGraphP(n, 3, p)
else:
raise ValueError('Invalid graph type')
def test_lattice_reference():
G = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
Gl = lattice_reference(G, niter=1, seed=rng)
L = nx.average_shortest_path_length(G)
Ll = nx.average_shortest_path_length(Gl)
assert_true(Ll > L)
assert_raises(nx.NetworkXError, lattice_reference, nx.Graph())
assert_raises(nx.NetworkXNotImplemented, lattice_reference, nx.DiGraph())
H = nx.Graph(((0, 1), (2, 3)))
Hl = lattice_reference(H, niter=1)
def test_random_reference():
G = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
Gr = random_reference(G, niter=1, seed=rng)
C = nx.average_clustering(G)
Cr = nx.average_clustering(Gr)
assert_true(C > Cr)
assert_raises(nx.NetworkXError, random_reference, nx.Graph())
assert_raises(nx.NetworkXNotImplemented, random_reference, nx.DiGraph())
H = nx.Graph(((0, 1), (2, 3)))
Hl = random_reference(H, niter=1, seed=rng)
def generate_network(pathwaysNum, genesNum, connNeighboors, connProbability):
pathways = []
for n in range(0, pathwaysNum):
pathway = nx.connected_watts_strogatz_graph(genesNum, connNeighboors,
connProbability)
[pathway.add_node(x) for x in range(genesNum)]
# Pathways are initialized as independant Watts-Strogatz networks
mapping = dict(
zip(pathway.nodes(), [x+genesNum*n for x in pathway.nodes()]))
pathway = nx.relabel_nodes(pathway, mapping)
pathways.append(pathway)
PPI = nx.union_all(pathways)
return PPI
def get_graph(self):
log.debug("Constructing Watts-Strogatz SW lattice with k=%s and rewiring %s", self.lattice_coordination_number, self.rewiring)
graph = nx.connected_watts_strogatz_graph(self.simconfig.popsize, self.lattice_coordination_number, self.rewiring)
# now convert the resulting graph to have simple nodenames to use as keys
# We need to retain the original nodenames, because they're tuples which represent the position
# of the node in the lattice. So we first store them as attribution 'pos' and then convert
for nodename in graph.nodes():
graph.node[nodename]['pos'] = nodename
g = nx.convert_node_labels_to_integers(graph)
return g
def __init__(self, num_nodes, node_degree, rewire_prob, tries=100, seed=None): BaseGraph.__init__(self) self.num_nodes = num_nodes self.node_degree = node_degree self.rewire_prob = rewire_prob self.tries = tries self.seed = seed self.structure = nx.connected_watts_strogatz_graph( self.num_nodes, self.node_degree, self.rewire_prob, self.tries, self.seed )
def smallworld(G):
n = G.number_of_nodes()
d= nx.average_degree_connectivity(G)
c = sum(i[1] for i in d.items())
c0 = 0.75*(c-2)/(c-1)
beta = random.uniform(0.01,0.1)
try:
SG= nx.connected_watts_strogatz_graph(n,int(c),beta)
plot(SG)
c = ((1-beta)**3)*c0
print 'Global Clustering: {0}\t'.format(str(c)),
print 'Average path length : {0}\n'.format(str(nx.average_shortest_path_length(SG)))
except:
'Failed attempt to get connected small world graph..Try again!!!'
def init():
global g, positions
g = nx.connected_watts_strogatz_graph(n, l, p, tries=100, seed=None) #WS connected graph generator
#g = nx.barabasi_albert_graph(n, l, seed=None) #BA graph generator (can be non-connected)
critical = nx.betweenness_centrality(g)
keynodes = critical.values()
for nd in g.nodes_iter():
if keynodes[nd]>0.43: #average value of ten highest bc over repeated iterations for WS
#if keynodes[nd]<0.0001: #average value of ten highest bc over repeated iterations for BA
g.node[nd]['state'] = rnd.choice([1, 2, 3, 4])
else:
g.node[nd]['state'] = 0
positions = nx.circular_layout(g) #for WS networks
def init_graph(self,g='reg',k=2):
"""Creates a graph of type g"""
self.diseasenetwork.add_nodes_from(self.agents)
#Rewiring of graphs could count as random_mixing
#Types of random graphs
gtype = { 'er':nx.fast_gnp_random_graph(self.population,0.05),
'nws':nx.newman_watts_strogatz_graph(self.population,k,0.5),
'ws':nx.watts_strogatz_graph(self.population,k,0.5),
'cws':nx.connected_watts_strogatz_graph(self.population,k,0.5,10),
'ba':nx.barabasi_albert_graph(self.population,k),
'reg':nx.random_regular_graph(k,self.population),
'grid':nx.grid_2d_graph(self.population/2,self.population/2) }
#This is causing the trouble need to map each edge to nodes :)
if g == 'grid':
self.diseasenetwork.add_edges_from([ (self.agents[x[0]],self.agents[y[0]]) for x,y in gtype[g].edges() ])
else:
self.diseasenetwork.add_edges_from([ (self.agents[x],self.agents[y]) for x,y in gtype[g].edges() ])
def asp_and_cc_vs_p():
N_NODES = 1000
EPSILON = 0.01
asp_and_cc_vs_p_dict = dict()
average_shortest_path_length = []
clustering_coefficient = []
probability = []
n_nodes = N_NODES
prob = 0.0
c0 = None
l0 = None
while prob <= 1:
ws_graph = nx.connected_watts_strogatz_graph(n_nodes, 4, prob) # Using networkx for finding the graph
avg_shortest_path = nx.average_shortest_path_length(ws_graph)
average_shortest_path_length.append(float("{0:.2f}".format(avg_shortest_path))) # Store shortest path of the graph
print 'avg. shortest path length: ' + str(float("{0:.2f}".format(avg_shortest_path)))
probability.append(prob) # Store probability
print 'probability: ' + str(prob)
cc = nx.average_clustering(ws_graph)
clustering_coefficient.append(cc) # Store clustering coefficient
print 'clustering coefficient: ' + str(cc)
if prob == 0.0: #Only first iteration
c0 = cc
l0 = float("{0:.2f}".format(avg_shortest_path))
prob += EPSILON
asp_and_cc_vs_p_dict['probability'] = probability
asp_and_cc_vs_p_dict['average_shortest_path_length'] = average_shortest_path_length
asp_and_cc_vs_p_dict['clustering_coefficient'] = clustering_coefficient
return asp_and_cc_vs_p_dict, c0, l0
def create_graph(self, params):
# case statements on type of graph
if self.type == 'small_world':
self.graph = nx.watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3]))
cg.SWC += 1
self.idx = cg.SWC
self.path = 'smallWorldGraphs'
elif self.type == 'small_world_connected':
self.graph = nx.connected_watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), 100 if len(params) < 4 else int(params[3]), None if len(params) < 5 else int(params[4]))
cg.SWCC += 1
self.idx = cg.SWCC
self.path = 'smallWorldConnectedGraphs'
elif self.type == 'small_world_newman':
self.graph = nx.newman_watts_strogatz_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3]))
cg.SWNC += 1
self.idx = cg.SWNC
self.path = 'smallWorldNewmanGraphs'
elif self.type == 'power_law':
self.graph = nx.powerlaw_cluster_graph(int(params[0]), int(params[1]), float(params[2]), None if len(params) < 4 else int(params[3]))
cg.PLC += 1
self.idx = cg.PLC
self.path = 'powerLawGraphs'
elif self.type == 'power_law_tree':
self.graph = nx.random_powerlaw_tree(int(params[0]), 3 if len(params) < 2 else float(params[1]), None if len(params) < 3 else int(params[2]), 100 if len(params) < 4 else int(params[3]))
cg.PLTC += 1
self.idx = cg.PLTC
self.path = 'powerLawTreeGraphs'
elif self.type == 'random_graph':
self.graph = nx.gnm_random_graph(int(params[0]), int(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3]))
cg.RGC += 1
self.idx = cg.RGC
self.path = 'randomGraphs'
elif self.type == 'erdos_renyi_random':
self.graph = nx.erdos_renyi_graph(int(params[0]), float(params[1]), None if len(params) < 3 else int(params[2]), False if len(params) < 4 else bool(params[3]))
cg.ERRC += 1
self.idx = cg.ERRC
self.path = 'erdosRenyiRandomGraphs'
else:
print 'GRAPH TYPE:', self.type
raise Exception('Invalid Type of Graph input into argv[2]')
def __init__(self, num_switches=None):
super(SmallWorldTopology, self).__init__()
if not num_switches:
num_switches = 8
num_hosts=num_switches*4
# build graphman graph
graph = nx.connected_watts_strogatz_graph(num_switches, min(4, num_switches/3), float(0.3), seed=35)
# Add switches
for s in graph:
log.debug("Added switch %x" % s)
self.add_switch(s+1)
# Add edges
for s1, s2 in graph.edges():
self.add_link(s1+1, s2+1)
# Add hosts
hostoffset = num_switches+2
for h in range(1,num_hosts+1):
# Add host
host = h + hostoffset
self.add_host(host)
# Connect to a "random" switch
s = graph.nodes()[h % len(graph)]
self.add_link(host,s+1)
# Globally connected host
# self.add_host(999)
# for switch in graph:
# self.add_link(999, switch+1)
self.finalize()
def createGraph(gtype, n, p):
if (gtype == 'ER'):
return nx.erdos_renyi_graph(n, p)
elif (gtype == 'BA'):
return nx.barabasi_albert_graph(n, int(p * n))
elif (gtype == 'WS'):
return nx.connected_watts_strogatz_graph(n, 8, p)
elif (gtype == 'GEO'):
return graphGen.geoGraphP(n, 3, p)
elif (gtype == 'VZ'):
# Vazquez recommends p = 0.1, q = 0.7
# Gibson suggests p = 0.24, q = 0.887
qmap = {0.1:0.7, 0.24:0.887}
assert(p in qmap.keys())
return graphGen.VazquezGraph(n, p, qmap[p])
elif (gtype == 'EV'):
qmap = {0.1:0.7, 0.24:0.887}
assert(p in qmap.keys())
return graphGen.EVGraph(n, p, qmap[p], n//5, 0.8)
elif (gtype == 'SL'):
# values from Sole paper
return graphGen.SoleGraph(n, 0.53, 0.06)
else:
raise ValueError('Invalid graph type')
def test_graphtool_distance():
G = nx.connected_watts_strogatz_graph(n=2000, k=4, p=0.02, tries=100, seed=None)
print 'NX: %.3f'%average_all_pairs_shortest_path(G)
print 'GT: %.3f'%average_all_pairs_shortest_path_GT(G)
print 'NX sampling: %.3f'%average_all_pairs_shortest_path_estimate(G)
print 'GT sampling: %.3f'%average_all_pairs_shortest_path_estimate_GT(G)
#Erdos-Renyi
if False:
G = nx.erdos_renyi_graph(100,.05) #(nodesize, p)
#Barabasi-Albert
if True:
G = nx.barabasi_albert_graph(500,2) #(nodesize, m)
if False:
G = nx.watts_strogatz_graph(500, 4, .3, seed=None)
if False:
G = nx.davis_southern_women_graph()
if False:
G = nx.connected_watts_strogatz_graph(500, 4, .3, seed=None)
#Graphs too big for me to run (Facebook requires 9GB of available RAM):
#G = nx.read_gexf("ER_random-1.gexf", node_type=int)
#G = nx.read_gexf("barabasi.gexf", node_type=int)
#G = nx.read_gexf("facebook_combined.gexf", node_type=int)
#G = nx.read_gexf("General_Relativity.gexf", node_type=int)
#Setting up the plot
cf = plt.figure(1, figsize=(8,8))
pos = nx.graphviz_layout(G)
ax = cf.add_axes((0,0,1,1))
for n in G:
G.node[n]['draw'] = nx.draw_networkx_nodes(G,pos,nodelist=[n], with_labels=False,node_size=200,alpha=0.2,node_color='w')
plt.ion()
plt.show()
def small_world_graph(n_cells, degree, rewiring_p, tries=100):
g = nx.connected_watts_strogatz_graph(n_cells, degree, rewiring_p, tries)
for e in g.edges():
g[e[0]][e[1]]['weight'] = random.gammavariate(1.53, 350)
return g
def genG(n,k,p,tries=1000, seed=None):
g=nx.connected_watts_strogatz_graph(n,k,p,tries,seed) # networkx graph
a=np.array(nx.adjacency_matrix(g).todense()) # adjacency matrix
return g, np.array(a, dtype=np.int32)
def test_sigma():
Gs = nx.connected_watts_strogatz_graph(100, 6, 0.1)
Gr = nx.connected_watts_strogatz_graph(100, 6, 1)
sigmas = sigma(Gs, niter=1, nrand=2)
sigmar = sigma(Gr, niter=1, nrand=2)
assert_true(sigmar < sigmas)
def test_sigma():
Gs = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
Gr = nx.connected_watts_strogatz_graph(50, 6, 1, seed=rng)
sigmas = sigma(Gs, niter=1, nrand=2, seed=rng)
sigmar = sigma(Gr, niter=1, nrand=2, seed=rng)
assert_true(sigmar < sigmas)
import os
import random
import networkx as nx
import matplotlib.pyplot as plt
n = 20000
d = 6
p = 0.4
G = nx.connected_watts_strogatz_graph(n, d, p)
edges = G.edges()[:]
random.shuffle(edges)
for edge in edges:
print edge[0], edge[1], 1
"""
# draw graph
pos = nx.shell_layout(G)
print G.number_of_nodes()
print G.number_of_edges()
print G.edges()
nx.draw(G, pos)
# show graph
plt.show()
"""
zip([G]*num_chunks,
[True]*num_chunks,
[None]*num_chunks,
node_chunks))
# Reduce the partial solutions
bt_c = bt_sc[0]
for bt in bt_sc[1:]:
for n in bt:
bt_c[n] += bt[n]
return bt_c
if __name__ == "__main__":
G_ba = nx.barabasi_albert_graph(1000, 3)
G_er = nx.gnp_random_graph(1000, 0.01)
G_ws = nx.connected_watts_strogatz_graph(1000, 4, 0.1)
for G in [G_ba, G_er, G_ws]:
print("")
print("Computing betweenness centrality for:")
print(nx.info(G))
print("\tParallel version")
start = time.time()
bt = betweenness_centrality_parallel(G)
print("\t\tTime: %.4F" % (time.time()-start))
print("\t\tBetweenness centrality for node 0: %.5f" % (bt[0]))
print("\tNon-Parallel version")
start = time.time()
bt = nx.betweenness_centrality(G)
print("\t\tTime: %.4F seconds" % (time.time()-start))
print("\t\tBetweenness centrality for node 0: %.5f" % (bt[0]))
print("")
def generate_SM_graph(N, p, k, filename):
G = nx.connected_watts_strogatz_graph(N, k, p, None)
nx.write_edgelist(G, filename, '#', '\t', False, 'utf-8')
if match==0:
deploy_traits_desired *= (np.random.rand()*match_margin + (1.0-match_margin))
print "total traits, at least: \t", np.sum(np.sum(deploy_traits_desired))
# initialize robots
robots = initialize_robots(deploy_robots_init)
print "total robots, init: \t", np.sum(np.sum(deploy_robots_init))
print "total traits, init: \t", np.sum(np.sum(deploy_traits_init))
# -----------------------------------------------------------------------------#
# initialize graph
if not load_data:
graph = nx.connected_watts_strogatz_graph(num_nodes, 3, 0.7)
else:
graph = pickle.load(open(load_prefix+"graph.p", "rb"))
# get the adjencency matrix
adjacency_m = nx.to_numpy_matrix(graph)
adjacency_m = np.squeeze(np.asarray(adjacency_m))
if plot_graph:
plt.axis('equal')
fig1 = nxmod.draw_circular(deploy_traits_init, graph,linewidths=3)
plt.show()
plt.axis('equal')
fig2 = nxmod.draw_circular(deploy_traits_desired, graph, linewidths=3)
plt.show()
def __init__(self,N_agents,Ri=2,R=25,U=10,comm_error=0.1,\
min_gain=lambda: 0.0001,agentClass=None,budget=1,silent=False,turns=1000,G=None,\
generate_graph=False,selfishness=lambda: 0.5):
self.silent = silent
self.comm = MPI.COMM_WORLD
self.mpi_size = self.comm.Get_size()
self.rank = self.comm.Get_rank()
if G is None:
if self.rank == 0:
if generate_graph:
G = nx.connected_watts_strogatz_graph(N_agents,4,0.5)
else:
G = nx.cycle_graph(N_agents)
self._G = self.comm.bcast(G,root=0)
if agentClass is None:
agentClass = Agent
R = float(R) * N_agents
self._N = N_agents # Number of global agents
self._Ri = float(Ri)
self._R = float(R)
self._U = float(U)
self.budget = float(budget)
self._turns = turns
# number of agents for each worker
base = np.floor(self._N / float(self.mpi_size))
# hangover
leftover = self._N % self.mpi_size
sizes = np.ones(self.mpi_size)*base
sizes[:leftover]+=1
offsets = np.zeros(self.mpi_size)
offsets[1:] = np.cumsum(sizes)[:-1]
self.mpi_gather_sizes = sizes
self.mpi_gather_offsets = offsets
start = offsets[self.rank]
end = start + sizes[self.rank]
agent_idxs = np.arange(start,end)
self.local_agents = [agentClass(idx=i,R=R,
s=max([0,min([0.99,selfishness()])]),
# s=0.9,
controller=self,
min_gain=min_gain(),
turns=turns) for i in agent_idxs]
if not(self.silent):
print "number of agents in rank {}:{}\n{}".format(self.rank,\
len(self.local_agents),agent_idxs)
for agent in self.local_agents:
# print agent.min_gain,agent.s
agent.k = randint(10)+1
agent.budget=self.budget/self._N
agent.alpha = 0.3
agent.omega = 3+rand()
# agent.nn = [agent.idx-1,(agent.idx+1)%self._N]
agent.nn = self._G.neighbors(agent._idx)
self._comm_error = comm_error
self._I = []
self._Pout = []
self._Us = []
self._Rg = []
self._n = 0 # Number of steps we did
self.is_constrained = True
self._global_P = [1]
self._global_dP_list = [1]
self._global_dP = 0
self.calc_global_dP = False
self.globalGameState = {0:np.zeros(self._N,dtype=np.int8)}
pass
