def test_navigable_small_world(self):
G = nx.navigable_small_world_graph(5, p=1, q=0)
gg = nx.grid_2d_graph(5, 5).to_directed()
assert_true(nx.is_isomorphic(G, gg))
G = nx.navigable_small_world_graph(5, p=1, q=0, dim=3)
gg = nx.grid_graph([5, 5, 5]).to_directed()
assert_true(nx.is_isomorphic(G, gg))
G = nx.navigable_small_world_graph(5, p=1, q=0, dim=1)
gg = nx.grid_graph([5]).to_directed()
assert_true(nx.is_isomorphic(G, gg))
def test_navigable_small_world(self):
G = nx.navigable_small_world_graph(5, p=1, q=0, seed=42)
gg = nx.grid_2d_graph(5, 5).to_directed()
assert nx.is_isomorphic(G, gg)
G = nx.navigable_small_world_graph(5, p=1, q=0, dim=3)
gg = nx.grid_graph([5, 5, 5]).to_directed()
assert nx.is_isomorphic(G, gg)
G = nx.navigable_small_world_graph(5, p=1, q=0, dim=1)
gg = nx.grid_graph([5]).to_directed()
assert nx.is_isomorphic(G, gg)
def adjmat(
size,
p=1,
q=1,
r=2,
dim=2,
inhib=0.15,
show=True): #CHANGE SO THAT HIGHEST OUT-DEGREE NEURONS ARE INHIBITORY
directed_sw = nx.navigable_small_world_graph(
size, p, q, r, dim
) #A navigable small-world graph is a directed grid with additional long-range connections that are chosen randomly.
#nx.draw_circular(directed_sw)
aspl = nx.average_shortest_path_length(directed_sw)
acc = nx.average_clustering(directed_sw)
print("Average shortest path length: " + str(aspl))
print("Average clustering coefficient: " + str(acc))
aij = nx.to_numpy_matrix(directed_sw)
#ADDING INHIBTORY NEURONS
if dim == 1:
ind = [j for j in range(size)]
inh = random.sample(ind, k=math.ceil(
inhib *
size)) #CHANGE SO THAT HIGHEST OUT-DEGREE NEURONS ARE INHIBITORY
elif dim == 2:
ind = [j for j in range(size**2)]
inh = random.sample(ind, k=math.ceil(
inhib * size**
2)) #CHANGE SO THAT HIGHEST OUT-DEGREE NEURONS ARE INHIBITORY
for i in inh:
aij[i, :] *= -1
if show:
# plt.figure()
plt.matshow(aij)
plt.show()
return aij, aspl, acc #Returns the graph adjacency matrix as a NumPy matrix.
def gen_lattice_graph(nodes):
dim = 2
n = int(nodes**(1.0 / dim))
p = 2 # short range connection diameter
short_connection_count = 2 * p * (p + 1)
connections_per_node = 50
q = connections_per_node - short_connection_count # long range connection count
return nx.navigable_small_world_graph(n, p, q, 2, dim)
def gen_lattice_graph(nodes): dim = 2 n = int(nodes ** (1.0/dim)) p = 2 # short range connection diameter short_connection_count = 2 * p * (p + 1) connections_per_node = 50 q = connections_per_node - short_connection_count # long range connection count return nx.navigable_small_world_graph(n, p, q, 2, dim)
def __init__(self,
n=DEFAULT_N,
p=DEFAULT_P,
q=DEFAULT_Q,
r=DEFAULT_R,
dim=DEFAULT_DIM,
seed=None):
self.G = nx.navigable_small_world_graph(n, p, q, r, dim, seed)
self.pos = None
def makeRandomDiGraph():
g = nx.navigable_small_world_graph(8,1,1,11,2, 42)
g = nx.convert_node_labels_to_integers(g, 0)
pos = nx.spectral_layout(g)
for n,nbrs in g.adjacency_iter():
g.node[n]['x'] = pos[n][0]
g.node[n]['y'] = pos[n][1]
#g.node[n]['name'] = n #str(n)
for nbr,eattr in nbrs.items():
eattr['weight'] = np.linalg.norm(pos[nbr]-pos[n],2)
return (g,pos)
def make_small_worlds():
#for N in [10,20,30,40,50]:
for N in [3, 10,20,30,40,50]:
G = nx.navigable_small_world_graph(N, p=1, q=1, r=2, dim=2, seed=None).to_undirected()
G = nx.relabel_nodes(G, mapping)
R = random.sample(G.nodes(), N)
name = 'smallworld-{0}-0'.format(N)
write_graph(G, name, mapping((0,0)), mapping((N-1,N-1)), R)
R = random.sample(G.nodes(), (N*N)/2)
name = 'smallworld-{0}-1'.format(N)
write_graph(G, name, mapping((0,0)), mapping((N-1,N-1)),R)
def make_small_worlds():
#for N in [10,20,30,40,50]:
for N in [3, 10, 20, 30, 40, 50]:
G = nx.navigable_small_world_graph(N, p=1, q=1, r=2, dim=2,
seed=None).to_undirected()
G = nx.relabel_nodes(G, mapping)
R = random.sample(G.nodes(), N)
name = 'smallworld-{0}-0'.format(N)
write_graph(G, name, mapping((0, 0)), mapping((N - 1, N - 1)), R)
R = random.sample(G.nodes(), (N * N) / 2)
name = 'smallworld-{0}-1'.format(N)
write_graph(G, name, mapping((0, 0)), mapping((N - 1, N - 1)), R)
def SM(self, r: int):
sm = nx.navigable_small_world_graph(32, 1, 1, r)
dic = {}
enum = 0
for i in range(0, 32):
for j in range(0, 32):
dic[(i, j)] = enum
enum += 1
g = nx.DiGraph()
#print(len(sm.nodes()))
g.add_nodes_from(range(0, 1024))
for e in sm.edges():
g.add_edge(dic[e[0]], dic[e[1]])
return g
def graphGenerator():
if args.graph_type == "erdos_renyi":
return networkx.erdos_renyi_graph(args.graph_size,args.graph_p)
if args.graph_type == "balanced_tree":
ndim = int(np.ceil(np.log(args.graph_size)/np.log(args.graph_degree)))
return networkx.balanced_tree(args.graph_degree,ndim)
if args.graph_type == "cicular_ladder":
ndim = int(np.ceil(args.graph_size*0.5))
return networkx.circular_ladder_graph(ndim)
if args.graph_type == "cycle":
return networkx.cycle_graph(args.graph_size)
if args.graph_type == 'grid_2d':
ndim = int(np.ceil(np.sqrt(args.graph_size)))
return networkx.grid_2d_graph(ndim,ndim)
if args.graph_type == 'lollipop':
ndim = int(np.ceil(args.graph_size*0.5))
return networkx.lollipop_graph(ndim,ndim)
if args.graph_type =='expander':
ndim = int(np.ceil(np.sqrt(args.graph_size)))
return networkx.margulis_gabber_galil_graph(ndim)
if args.graph_type =="hypercube":
ndim = int(np.ceil(np.log(args.graph_size)/np.log(2.0)))
return networkx.hypercube_graph(ndim)
if args.graph_type =="star":
ndim = args.graph_size-1
return networkx.star_graph(ndim)
if args.graph_type =='barabasi_albert':
return networkx.barabasi_albert_graph(args.graph_size,args.graph_degree)
if args.graph_type =='watts_strogatz':
return networkx.connected_watts_strogatz_graph(args.graph_size,args.graph_degree,args.graph_p)
if args.graph_type =='regular':
return networkx.random_regular_graph(args.graph_degree,args.graph_size)
if args.graph_type =='powerlaw_tree':
return networkx.random_powerlaw_tree(args.graph_size)
if args.graph_type =='small_world':
ndim = int(np.ceil(np.sqrt(args.graph_size)))
return networkx.navigable_small_world_graph(ndim)
if args.graph_type =='geant':
return topologies.GEANT()
if args.graph_type =='dtelekom':
return topologies.Dtelekom()
if args.graph_type =='abilene':
return topologies.Abilene()
if args.graph_type =='servicenetwork':
return topologies.ServiceNetwork()
def adjmat(size, p=1, q=1, r=2, dim=2, show=True): #default is p=1 and r=2
directed_sw = nx.navigable_small_world_graph(
size, p, q, r, dim
) #A navigable small-world graph is a directed grid with additional long-range connections that are chosen randomly.
nx.draw_circular(directed_sw)
aspl = nx.average_shortest_path_length(directed_sw)
acc = nx.average_clustering(directed_sw)
print("Average shortest path length: " + str(aspl))
print("Average clustering coefficient: " + str(acc))
aij = nx.to_numpy_matrix(directed_sw)
#ADDING INHIBTORY NEURONS
ind = [j for j in range(size**2)]
inh = random.sample(ind, k=math.ceil(
0.15 * size**2)) #15% OF NEURONS ARE INHIBITORY
for i in inh:
aij[i, :] *= -1
if show:
plt.matshow(aij)
return aij #Returns the graph adjacency matrix as a NumPy matrix.
def geometric_graphs():
print("Random geometric graphs")
G = nx.random_geometric_graph(20, 0.1)
draw_graph(G)
n = 20
p = {i: (random.gauss(0, 2), random.gauss(0, 2)) for i in range(n)}
G = nx.random_geometric_graph(n, 0.2, pos=p)
draw_graph(G)
print("Geographical threshold graph")
n = 10
w = {i: random.expovariate(1.0) for i in range(n)}
G = nx.geographical_threshold_graph(n, 30, weight=w)
draw_graph(G)
print("Waxman graph")
G = nx.waxman_graph(27)
draw_graph(G)
print("Navigable small world graph")
G = nx.navigable_small_world_graph(7)
draw_graph(G)
def navigable_small_world_graph(n):
g_aux = nx.navigable_small_world_graph(n,1,5, 1.0)
g = nx.Graph()
index = {}
for idx, v in enumerate(g_aux.nodes()):
(x,y) = v
g.add_node(idx)
g.node[idx]["x"] = x
g.node[idx]["y"] = y
index[v] = idx
for v in g_aux.nodes():
for w in g_aux.edge[v]:
idv = index[v]
idw = index[w]
g.add_edge(idv, idw, cost=1)#distance(g, idv, idw))
return g
def generate_world_graph(n=6, p=1, q=4, r=2):
"""
Uses nx.navigable_small_world_graph to generate a directed grid with additional
long range connections that are chosen randomly. For each node, each out edge is
assigned a probability such that the sum of all probabilities <= 1.0 (where the
remainder is the probability of staying in the node). Nodes are also assigned unique
random place names and given data attributes for use in the Graph.
"""
G = nx.navigable_small_world_graph(n, p=p, q=q, r=r, dim=2)
for node in G.nodes():
# Assign probabilities to all edges such that probabilities are <= 1
# TODO: ensure there isn't an edge to self
dist = np.random.dirichlet(np.ones(G.out_degree(node) + 1), size=1)[0]
for i, edge in enumerate(G.out_edges(node)):
G.edges[edge]["weight"] = dist[i]
G.edges[edge]["distance"] = np.linalg.norm(
np.asarray(edge[0]) - np.asarray(edge[1])
)
# Assign the travel distribution to the node for selection
G.nodes[node]["prob"] = np.cumsum(dist)
G.name = "Navigable Small World"
return G
# Set how many episodes you want?
episodes = 10000
# Set the epsilon for e-greedy action selection.
epsilon = 0.1
# Set the step size for updating action-value function.
alpha = 0.1
# Select which graph you want? Also set the source U and target V
# G = nx.convert_node_labels_to_integers(nx.grid_2d_graph(N, N))
# U = 0
# V = (N*N - 1)
G = nx.convert_node_labels_to_integers(nx.navigable_small_world_graph(N))
U = 0
V = (N*N - 1)
################################################################################
def clear_render():
plt.clf()
nx.draw_networkx(G, pos=pos)
plt.draw()
def is_valid(g): # returns a boolean. g is any subgraph of G.
# If not a simple path, then g is "not valid".
if not nx.is_simple_path(G, list(g.nodes)):
return False
for i in range(default_no_entities):
G = nx.scale_free_graph(default_size,
alpha=0.01,
beta=0.84,
gamma=0.15,
create_using=nx.Graph)
makedir(path_output_data_type + 'entity_' + str(i))
save_graph(path_output_data_type + 'entity_' + str(i) + '/' + 'J_ij.csv',
G)
#Random Small World Graph
#path_output_data_type = path_output_data + 'small_world/'
#makedir(path_output_data_type)
#for i in range(default_no_entities):
G = nx.navigable_small_world_graph(np.sqrt(default_size).astype(np.int8))
# makedir(path_output_data_type + 'entity_' + str(i))
# save_graph(path_output_data_type + 'entity_' + str(i) + '/' + 'J_ij.csv', G)
# Random Intersection Graph
path_output_data_type = path_output_data + 'intersection/'
makedir(path_output_data_type)
for i in range(default_no_entities):
G = nx.k_random_intersection_graph(default_size, 10, 2)
makedir(path_output_data_type + 'entity_' + str(i))
save_graph(path_output_data_type + 'entity_' + str(i) + '/' + 'J_ij.csv',
G)
# Social Graph
path_output_data = path_input + 'social/'
def gen_laplacian(data_num=DATA_NUM, opt=27, cache=False):
label = None
if cache:
print('Loading cached graph')
graph = pk.load(open('tmp/g.pk', 'rb'))
else:
print('Generating graph opt {}'.format(opt))
if 1 == opt:
graph = gen_rand_graph(data_num=data_num)
if 2 == opt:
top_num = random.randint(1, data_num)
bottom_num = data_num - top_num
graph = nx.bipartite.random_graph(top_num, bottom_num, 0.9)
label = [d['bipartite'] for n, d in graph.nodes(data=True)]
elif 3 == opt:
graph = nx.balanced_tree(4, 5)
elif 4 == opt:
graph = nx.complete_graph(data_num)
elif 5 == opt:
no1 = random.randint(1, data_num)
no2 = random.randint(1, int(data_num / no1))
no3 = data_num / no1 / no2
graph = nx.complete_multipartite_graph(no1, no2, no3)
elif 6 == opt:
graph = nx.circular_ladder_graph(data_num)
elif 7 == opt:
graph = nx.cycle_graph(data_num)
elif 8 == opt:
graph = nx.dorogovtsev_goltsev_mendes_graph(5)
elif 9 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num / top_num
graph = nx.grid_2d_graph(top_num, bottom_num)
elif 10 == opt:
no1 = random.randint(1, data_num)
no2 = random.randint(1, int(data_num / no1))
no3 = data_num / no1 / no2
graph = nx.grid_graph([no1, no2, no3])
elif 11 == opt:
graph = nx.hypercube_graph(10)
elif 12 == opt:
graph = nx.ladder_graph(data_num)
elif 13 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.lollipop_graph(top_num, bottom_num)
elif 14 == opt:
graph = nx.path_graph(data_num)
elif 15 == opt:
graph = nx.star_graph(data_num)
elif 16 == opt:
graph = nx.wheel_graph(data_num)
elif 17 == opt:
graph = nx.margulis_gabber_galil_graph(35)
elif 18 == opt:
graph = nx.chordal_cycle_graph(data_num)
elif 19 == opt:
graph = nx.fast_gnp_random_graph(data_num, random.random())
elif 20 == opt: # jump eigen value
graph = nx.gnp_random_graph(data_num, random.random())
elif 21 == opt: # disconnected graph
graph = nx.dense_gnm_random_graph(data_num, data_num / 2)
elif 22 == opt: # disconnected graph
graph = nx.gnm_random_graph(data_num, data_num / 2)
elif 23 == opt:
graph = nx.erdos_renyi_graph(data_num, data_num / 2)
elif 24 == opt:
graph = nx.binomial_graph(data_num, data_num / 2)
elif 25 == opt:
graph = nx.newman_watts_strogatz_graph(data_num, 5,
random.random())
elif 26 == opt:
graph = nx.watts_strogatz_graph(data_num, 5, random.random())
elif 26 == opt: # smooth eigen
graph = nx.connected_watts_strogatz_graph(data_num, 5,
random.random())
elif 27 == opt: # smooth eigen
graph = nx.random_regular_graph(5, data_num)
elif 28 == opt: # smooth eigen
graph = nx.barabasi_albert_graph(data_num, 5)
elif 29 == opt: # smooth eigen
graph = nx.powerlaw_cluster_graph(data_num, 5, random.random())
elif 30 == opt: # smooth eigen
graph = nx.duplication_divergence_graph(data_num, random.random())
elif 31 == opt:
p = random.random()
q = random.random()
graph = nx.random_lobster(data_num, p, q)
elif 32 == opt:
p = random.random()
q = random.random()
k = random.random()
graph = nx.random_shell_graph([(data_num / 3, 50, p),
(data_num / 3, 40, q),
(data_num / 3, 30, k)])
elif 33 == opt: # smooth eigen
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.k_random_intersection_graph(top_num, bottom_num, 3)
elif 34 == opt:
graph = nx.random_geometric_graph(data_num, .1)
elif 35 == opt:
graph = nx.waxman_graph(data_num)
elif 36 == opt:
graph = nx.geographical_threshold_graph(data_num, .5)
elif 37 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.uniform_random_intersection_graph(
top_num, bottom_num, .5)
elif 39 == opt:
graph = nx.navigable_small_world_graph(data_num)
elif 40 == opt:
graph = nx.random_powerlaw_tree(data_num, tries=200)
elif 41 == opt:
graph = nx.karate_club_graph()
elif 42 == opt:
graph = nx.davis_southern_women_graph()
elif 43 == opt:
graph = nx.florentine_families_graph()
elif 44 == opt:
graph = nx.complete_multipartite_graph(data_num, data_num,
data_num)
# OPT 1
# norm_lap = nx.normalized_laplacian_matrix(graph).toarray()
# OPT 2: renormalized
# pk.dump(graph, open('tmp/g.pk', 'wb'))
# plot_graph(graph, label)
# note difference: normalized laplacian and normalzation by eigenvalue
norm_lap, eigval, eigvec = normalize_lap(graph)
return graph, norm_lap, eigval, eigvec
import networkx import pynetsim a = networkx.navigable_small_world_graph(1000, 4, 2, 1, 1).to_undirected() pynetsim.randomize(a) b = a.copy() c = a.copy() numattackers = 2 attackers = list() pynetsim.pickmalnodes(a, attackers, 2) pynetsim.attacksimulation(a, attackers) for m in attackers: print m locations = list() for n in a.nodes(): locations.append(n[0]) hist(locations, 100)
import matplotlib.pyplot as plt
import networkx as nx
G = nx.navigable_small_world_graph(
2, 1, 1, 2, 2) # Not Really sure what to do with this...
nx.draw(G)
plt.show()
import networkx import pynetsim a = networkx.navigable_small_world_graph(1000, 4, 2, 1, 1).to_undirected() pynetsim.randomize(a) attackers = list() pynetsim.pickmalnodes(a, attackers, 10) pynetsim.attacksimulation(a, attackers)
