def test_graph2vec():
"""
Test the Graph2Vec embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = Graph2Vec()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.dimensions
graphs = []
for _ in range(50):
graph = nx.newman_watts_strogatz_graph(50, 5, 0.3)
nx.set_node_attributes(graph, {j: str(j)
for j in range(50)}, "feature")
graphs.append(graph)
model = Graph2Vec(attributed=True)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
def test_label_propagation():
"""
Test Label Propagation procedure.
"""
graph = nx.newman_watts_strogatz_graph(50, 5, 0.3)
model = LabelPropagation()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
graph = nx.newman_watts_strogatz_graph(150, 5, 0.3)
model = LabelPropagation()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
def test_gl2vec():
"""
Test the GL2Vec embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = GL2Vec()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
graphs = [nx.newman_watts_strogatz_graph(150, 5, 0.3) for _ in range(100)]
model = GL2Vec(dimensions=16)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
def test_fgsd():
"""
Test the FGSD embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = FGSD()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.hist_bins
assert type(embedding) == np.ndarray
graphs = [nx.newman_watts_strogatz_graph(150, 5, 0.3) for _ in range(100)]
model = FGSD(hist_bins=8)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.hist_bins
assert type(embedding) == np.ndarray
def test_ldp():
"""
Test the LDP embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = LDP(bins=8)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == 5 * model.bins
assert type(embedding) == np.ndarray
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(1000)]
model = LDP(bins=128)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == 5 * model.bins
assert type(embedding) == np.ndarray
def generateNetwork(N,cnType,weighted):
# Input:
# N - number of nodes
# cnType - network type (i.e. scale-free, small-world, Erdos-Renyi random graph)
# weighted - weighted or unweighted network
# Output:
# G - a network with random generated topology acoording with the input parameters
if (cnType == "scale-free"):
G = nx.powerlaw_cluster_graph(N, 5, 0.3)
while (nx.is_connected(G) == False):
G = nx.powerlaw_cluster_graph(N, 5, 0.3)
if (cnType == "small-world"):
G = nx.newman_watts_strogatz_graph(N, 6, 0.6)
while (nx.is_connected(G) == False):
G = nx.newman_watts_strogatz_graph(N, 6, 0.6)
if (cnType == "Erdos-Renyi"):
G = nx.fast_gnp_random_graph(N, 0.01)
while (nx.is_connected(G) == False):
G = nx.fast_gnp_random_graph(N, 0.01)
if (weighted):
G = generateWeightedNetwork(G)
else:
G = generateUnweightedNetwork(G)
return G
def test_netlsd():
"""
Test the NetLSD embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = NetLSD()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.scale_steps
assert type(embedding) == np.ndarray
graphs = [nx.newman_watts_strogatz_graph(500, 5, 0.3) for _ in range(100)]
model = NetLSD()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == model.scale_steps
assert type(embedding) == np.ndarray
def test_egonet_splitter():
"""
Test the Ego Net splitter procedure.
"""
graph = nx.newman_watts_strogatz_graph(100, 5, 0.3)
model = EgoNetSplitter()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
graph = nx.newman_watts_strogatz_graph(150, 5, 0.3)
model = EgoNetSplitter()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
def test_bane():
"""
Testing the BANE node embedding.
"""
graph = nx.newman_watts_strogatz_graph(250, 10, 0.2)
features = np.random.uniform(0, 1, (250, 256))
model = BANE()
model.fit(graph, features)
embedding = model.get_embedding()
assert embedding.shape[0] == graph.number_of_nodes()
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
graph = nx.newman_watts_strogatz_graph(150, 10, 0.2)
features = np.random.uniform(0, 1, (150, 256))
model = BANE(dimensions=8)
model.fit(graph, features)
embedding = model.get_embedding()
assert embedding.shape[0] == graph.number_of_nodes()
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
def test_feather_graph():
"""
Test the graph level FEATHER embedding.
"""
graphs = [nx.newman_watts_strogatz_graph(50, 5, 0.3) for _ in range(100)]
model = FeatherGraph()
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == 4 * model.order * model.eval_points
assert type(embedding) == np.ndarray
graphs = [nx.newman_watts_strogatz_graph(150, 5, 0.3) for _ in range(100)]
model = FeatherGraph(order=3)
model.fit(graphs)
embedding = model.get_embedding()
assert embedding.shape[0] == len(graphs)
assert embedding.shape[1] == 4 * model.order * model.eval_points
assert type(embedding) == np.ndarray
def test_egonet_splitter():
"""
Test the Ego Net splitter procedure.
"""
graph = nx.newman_watts_strogatz_graph(100, 5, 0.3)
model = EgoNetSplitter()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
graph = nx.newman_watts_strogatz_graph(150, 5, 0.3)
model = EgoNetSplitter()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
# Test weighted graph
graph = nx.les_miserables_graph()
graph = nx.convert_node_labels_to_integers(graph)
model = EgoNetSplitter(weight='weight')
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
# Force unweighted
graph = nx.les_miserables_graph()
graph = nx.convert_node_labels_to_integers(graph)
model = EgoNetSplitter(weight=None)
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
def sym_bar_like_network(nodes_per_half=7, seed_a=1, seed_b=2):
"""Symmetrical bar bell like network"""
a = nx.newman_watts_strogatz_graph(nodes_per_half, 4, 0.1, seed=seed_a)
b = nx.newman_watts_strogatz_graph(nodes_per_half, 4, 0.1, seed=seed_b)
G = nx.compose(
a, nx.convert_node_labels_to_integers(b, first_label=nodes_per_half))
G.add_edge(nodes_per_half - 1, nodes_per_half)
# nx.draw_kamada_kawai(G)
# plt.show()
return G
def test_mnmf():
"""
Test the MNMF procedure.
"""
graph = nx.newman_watts_strogatz_graph(100, 5, 0.3)
model = MNMF()
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
embedding = model.get_embedding()
assert embedding.shape[0] == graph.number_of_nodes()
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
centers = model.get_cluster_centers()
assert centers.shape[0] == model.clusters
assert centers.shape[1] == model.dimensions
assert type(centers) == np.ndarray
graph = nx.newman_watts_strogatz_graph(200, 5, 0.3)
model = MNMF(dimensions=8)
model.fit(graph)
memberships = model.get_memberships()
indices = [k for k, v in memberships.items()].sort()
nodes = [node for node in graph.nodes()].sort()
assert graph.number_of_nodes() == len(memberships)
assert indices == nodes
assert type(memberships) == dict
embedding = model.get_embedding()
assert embedding.shape[0] == graph.number_of_nodes()
assert embedding.shape[1] == model.dimensions
assert type(embedding) == np.ndarray
centers = model.get_cluster_centers()
assert centers.shape[0] == model.clusters
assert centers.shape[1] == model.dimensions
assert type(centers) == np.ndarray
def test_watts_strogatz_big_k(self):
# Test to make sure than n <= k
pytest.raises(nx.NetworkXError, nx.watts_strogatz_graph, 10, 11, 0.25)
pytest.raises(nx.NetworkXError, nx.newman_watts_strogatz_graph, 10, 11,
0.25)
# could create an infinite loop, now doesn't
# infinite loop used to occur when a node has degree n-1 and needs to rewire
nx.watts_strogatz_graph(10, 9, 0.25, seed=0)
nx.newman_watts_strogatz_graph(10, 9, 0.5, seed=0)
# Test k==n scenario
nx.watts_strogatz_graph(10, 10, 0.25, seed=0)
nx.newman_watts_strogatz_graph(10, 10, 0.25, seed=0)
def get_graph(objects, properties):
graph_type = properties['graph_type']
n = len(objects)-1
if 'num_nodes_to_attach' in properties.keys():
k = properties['num_nodes_to_attach']
else:
k = 3
r = properties['connection_probability']
tries = 0
while(True):
if graph_type == 'random':
x = nx.fast_gnp_random_graph(n,r)
elif graph_type == 'erdos_renyi_graph':
x = nx.erdos_renyi_graph(n,r)
elif graph_type == 'watts_strogatz_graph':
x = nx.watts_strogatz_graph(n, k, r)
elif graph_type == 'newman_watts_strogatz_graph':
x = nx.newman_watts_strogatz_graph(n, k, r)
elif graph_type == 'barabasi_albert_graph':
x = nx.barabasi_albert_graph(n, k, r)
elif graph_type == 'powerlaw_cluster_graph':
x = nx.powerlaw_cluster_graph(n, k, r)
elif graph_type == 'cycle_graph':
x = nx.cycle_graph(n)
else: ##Star by default
x = nx.star_graph(len(objects)-1)
tries += 1
cc_conn = nx.connected_components(x)
if len(cc_conn) == 1 or tries > 5:
##best effort to create a connected graph!
break
return x, cc_conn
def small_world_graph(n, k, p, seed=None):
'''
n: number of node
k: number of nearest neighbors in a ring topology
p: probability of adding a new edge for each edge
'''
return nx.newman_watts_strogatz_graph(n, k, p)
def make_network(cores, number_of_neurons, netsize, connect_break):
out_list = []
test_net = nx.newman_watts_strogatz_graph(1000, netsize, 0)
factor = 5
for nn in test_net.nodes():
if np.min(np.abs(cores - nn)) < 15:
for i in range(factor):
rand_core = cores[int(np.round(np.random.random() * 6))]
test_net.add_edge(nn, np.random.randint(0, 1000))
for ed in test_net.edges():
if np.random.random() > connect_break:
continue
if np.abs(ed[0] - ed[1]) > 20 and np.abs(ed[0] - ed[1]) < 700:
rng = np.random.choice([-1, 0, 0, 1])
elif np.abs(ed[0] - ed[1]) > 700:
rng = 1000
else:
rng = np.random.choice([0, 0, 0, 0, 0])
if rng == 0:
out_list.append(ed)
out_list.append(ed[::-1])
elif rng == 1:
out_list.append(ed)
elif rng == -1:
out_list.append(ed[::-1])
else:
pass
return out_list
def main():
G = nx.complete_graph(10)
#完全グラフ
G2 = nx.barbell_graph(10, 10)
#ようわからん
G3 = nx.watts_strogatz_graph(100, 15, 0.1)
#small world graph
#watts_strogatz_graph(n,k,p) n: number of node, k:nearest neoghbors,
G4 = nx.complete_bipartite_graph(3, 3)
#完全二部グラフ
G5 = nx.scale_free_graph(50)
G6 = nx.newman_watts_strogatz_graph(100, 10, 0.05)
G7 = nx.binomial_graph(10, 0.2)
# z=[int(random.gammavariate(alpha=9.0,beta=2.0)) for i in range(6)]
# G8 = nx.configuration_model(z)
# aseq = [1,2,1]
# bseq = [2,1,1]
# G8 = nx.configuration_model(aseq,bseq)
G8 = bp.random_graph(5, 5, 0.5)
pos = nx.spring_layout(G6)
# pos = nx.circular_layout(G5)
plt.axis('off')
nx.draw(G6, pos, with_labels=False)
plt.show()
def set_graph(self, graphtype, graphparams):
if graphtype == 'hexagonal':
self.G = nx.triangular_lattice_graph(**graphparams)
elif graphtype == 'watts strogatz':
self.G = nx.watts_strogatz_graph(**graphparams)
elif graphtype == 'newman watts strogatz':
self.G = nx.newman_watts_strogatz_graph(**graphparams)
elif graphtype == 'square':
self.G = nx.grid_2d_graph(**graphparams)
elif graphtype == 'random blocks':
self.G = nx.stochastic_block_model(**graphparams)
elif graphtype == 'powerlaw cluster':
self.G = nx.powerlaw_cluster_graph(**graphparams)
elif graphtype == 'scale-free small world':
self.G = clustered_scalefree(**graphparams)
elif graphtype == 'barabasi-albert':
self.G = nx.barabasi_albert_graph(**graphparams)
else:
print('Using complete graph')
self.G = nx.complete_graph(**graphparams)
def test_rand_structure_with_layer_norm_success():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Arrange
random_graph = nx.newman_watts_strogatz_graph(100, 4, 0.5)
# print("Random graph has %s edges." % len(random_graph.edges))
structure = deepstruct.graph.CachedLayeredGraph()
structure.add_edges_from(random_graph.edges)
structure.add_nodes_from(random_graph.nodes)
batch_size = 10
shape_input = (28, 28)
size_output = 10
random_input = torch.tensor(
np.random.random((batch_size, ) + shape_input),
device=device,
requires_grad=False,
)
model = deepstruct.sparse.MaskedDeepDAN(shape_input,
size_output,
structure,
use_layer_norm=True)
model.to(device)
# Act
model(random_input)
# Act
extracted_structure = model.generate_structure(include_input=False,
include_output=False)
assert len(structure.nodes) == len(extracted_structure.nodes)
assert len(structure.edges) == len(extracted_structure.edges)
assert nx.is_isomorphic(structure, extracted_structure)
def create_newman_WS_graphs(N, betas):
NUM_NEIGHBORS = 2
graphs = []
for beta in betas:
graphs.append(networkx.newman_watts_strogatz_graph(N, NUM_NEIGHBORS, beta))
return graphs
def walklets(population, neighbors, probability):
g = nx.newman_watts_strogatz_graph(population, neighbors, probability)
model = Walklets()
model.fit(g)
emb = model.get_embedding()
#print(emb.shape)
return [emb.shape]
def labelPropagation(population, neighbors, probability):
g = nx.newman_watts_strogatz_graph(population, neighbors, probability)
model = LabelPropagation()
model.fit(g)
#print(model.get_memberships())
return [model.get_memberships()]
def init_random(self, n=200, k=10, typ='random', p=.1, weighted=False, seed=None):
# add n nodes to the network in the start state -> S
self.add_mult(n, state='S', traced=False)
# initialize the rewire probability to k/n if p=None provided
p = k / n if p is None else p
links_to_create_dict = {
# Generate random pairs (edges) without replacement
'random': lambda: rand_pairs(n, int(n * k / 2), seed=seed),
'binomial': lambda: list(nx.fast_gnp_random_graph(n, p, seed=seed).edges),
# small-world network
'ws': lambda: list(nx.watts_strogatz_graph(n, k, p, seed=seed).edges),
'newman-ws': lambda: list(nx.newman_watts_strogatz_graph(n, k, p, seed=seed).edges),
# scale-free network
'barabasi': lambda: list(nx.barabasi_albert_graph(n, m=k, seed=seed).edges),
'powerlaw-cluster': lambda: list(nx.powerlaw_cluster_graph(n, m=k, p=p, seed=seed).edges),
# fully connected network
'complete': lambda: list(nx.complete_graph(n).edges),
}
try:
links_to_create = links_to_create_dict[typ]()
except KeyError:
print("The inputted network type is not supported. Default to: random", file=stderr)
links_to_create = links_to_create_dict['random']()
len_links = len(links_to_create)
if weighted:
# Create random weights from 1 to 10 and append them to the list of edge tuples
weights = random.choices(range(1,10), k=len_links)
links_to_create = [links_to_create[i] + (weights[i],) for i in range(len_links)]
# Add the random edges with/without weights depending on 'weighted' parameter
# we do not update the counts here because they will be updated after the infection has been seeded with first_inf
self.add_links(links_to_create, update=False)
def test_networkx_roundtrip(self):
print("\n---------- NetworkX Data Roundtrip Test Start -----------\n")
g = nx.newman_watts_strogatz_graph(100, 3, 0.5)
nodes = g.nodes()
edges = g.edges()
# Add some attributes
g.graph["name"] = "original"
g.graph["density"] = nx.density(g)
nx.set_node_attributes(g, "betweenness", nx.betweenness_centrality(g))
nx.set_node_attributes(g, "degree", nx.degree(g))
nx.set_node_attributes(g, "closeness", nx.closeness_centrality(g))
nx.set_edge_attributes(g, "eb", nx.edge_betweenness(g))
cyjs1 = util.from_networkx(g)
g2 = util.to_networkx(cyjs1)
self.assertEqual(len(g2.nodes()), len(nodes))
self.assertEqual(len(g2.edges()), len(edges))
edge_set = set(list(map(lambda x: (int(x[0]), int(x[1])), g2.edges())))
self.assertEqual(0, len(edge_set.difference(set(edges))))
node_original = g.node[1]
node_generated = g2.node["1"]
print(node_original)
print(node_generated)
self.assertEqual(node_original["degree"], node_generated["degree"])
self.assertEqual(node_original["betweenness"], node_generated["betweenness"])
self.assertEqual(node_original["closeness"], node_generated["closeness"])
def test_networkx_roundtrip(self):
print('\n---------- NetworkX Data Roundtrip Test Start -----------\n')
g = nx.newman_watts_strogatz_graph(100, 3, 0.5)
nodes = g.nodes()
edges = g.edges()
# Add some attributes
g.graph['name'] = 'original'
g.graph['density'] = nx.density(g)
nx.set_node_attributes(g, 'betweenness', nx.betweenness_centrality(g))
nx.set_node_attributes(g, 'degree', nx.degree(g))
nx.set_node_attributes(g, 'closeness', nx.closeness_centrality(g))
nx.set_edge_attributes(g, 'eb', nx.edge_betweenness(g))
cyjs1 = util.from_networkx(g)
g2 = util.to_networkx(cyjs1)
self.assertEqual(len(g2.nodes()), len(nodes))
self.assertEqual(len(g2.edges()), len(edges))
edge_set = set(list(map(lambda x: (int(x[0]), int(x[1])), g2.edges())))
self.assertEqual(0, len(edge_set.difference(set(edges))))
node_original = g.node[1]
node_generated = g2.node['1']
print(node_original)
print(node_generated)
self.assertEqual(node_original['degree'], node_generated['degree'])
self.assertEqual(node_original['betweenness'], node_generated['betweenness'])
self.assertEqual(node_original['closeness'], node_generated['closeness'])
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 get_graph(objects, properties):
graph_type = properties['graph_type']
n = len(objects) - 1
if 'num_nodes_to_attach' in properties.keys():
k = properties['num_nodes_to_attach']
else:
k = 3
r = properties['connection_probability']
tries = 0
while (True):
if graph_type == 'random':
x = nx.fast_gnp_random_graph(n, r)
elif graph_type == 'erdos_renyi_graph':
x = nx.erdos_renyi_graph(n, r)
elif graph_type == 'watts_strogatz_graph':
x = nx.watts_strogatz_graph(n, k, r)
elif graph_type == 'newman_watts_strogatz_graph':
x = nx.newman_watts_strogatz_graph(n, k, r)
elif graph_type == 'barabasi_albert_graph':
x = nx.barabasi_albert_graph(n, k, r)
elif graph_type == 'powerlaw_cluster_graph':
x = nx.powerlaw_cluster_graph(n, k, r)
elif graph_type == 'cycle_graph':
x = nx.cycle_graph(n)
else: ##Star by default
x = nx.star_graph(len(objects) - 1)
tries += 1
cc_conn = nx.connected_components(x)
if len(cc_conn) == 1 or tries > 5:
##best effort to create a connected graph!
break
return x, cc_conn
def smallworld(size, neighbors, edgeprob, seed=None):
assert size > 0
assert neighbors >= 0
assert edgeprob >= 0 and edgeprob <= 1
if seed:
g = nx.newman_watts_strogatz_graph(n=size, k=neighbors, p=edgeprob,
seed=seed)
else:
g = nx.newman_watts_strogatz_graph(n=size, k=neighbors, p=edgeprob)
g.name = 'Small World network: {s} nodes, {n} neighbors, ' \
'{p} edge probability'.format(s=size, n=neighbors, p=edgeprob)
return g
def test_networkx_roundtrip(self):
print('\n---------- NetworkX Data Roundtrip Test Start -----------\n')
g = nx.newman_watts_strogatz_graph(100, 3, 0.5)
nodes = g.nodes()
edges = g.edges()
# Add some attributes
g.graph['name'] = 'original'
g.graph['density'] = nx.density(g)
nx.set_node_attributes(g, 'betweenness', nx.betweenness_centrality(g))
nx.set_node_attributes(g, 'degree', nx.degree(g))
nx.set_node_attributes(g, 'closeness', nx.closeness_centrality(g))
nx.set_edge_attributes(g, 'eb', nx.edge_betweenness(g))
cyjs1 = util.from_networkx(g)
g2 = util.to_networkx(cyjs1)
self.assertEqual(len(g2.nodes()), len(nodes))
self.assertEqual(len(g2.edges()), len(edges))
edge_set = set(list(map(lambda x: (int(x[0]), int(x[1])), g2.edges())))
self.assertEqual(0, len(edge_set.difference(set(edges))))
node_original = g.node[1]
node_generated = g2.node['1']
print(node_original)
print(node_generated)
self.assertEqual(node_original['degree'], node_generated['degree'])
self.assertEqual(node_original['betweenness'], node_generated['betweenness'])
self.assertEqual(node_original['closeness'], node_generated['closeness'])
def test_graph_generator():
n = 400
m = 5
seed = 0
# G = nx.barabasi_albert_graph(n, m, seed)
G = nx.random_partition_graph([100, 100, 200], .25, .01)
sizes = [10, 90, 300]
probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
G = nx.stochastic_block_model(sizes, probs, seed=0)
G = nx.newman_watts_strogatz_graph(400, 5, 0.5)
A = nx.to_numpy_array(G)
print(A)
plt.pcolormesh(A)
plt.show()
s = sorted(G.degree, key=lambda x: x[1], reverse=True)
# newmap = {s[i][0]:i for i in range(len(s))}
# H= nx.relabel_nodes(G,newmap)
# newmap = generate_node_mapping(G, type='community')
# H = networkX_reorder_nodes(G, newmap)
H = networkx_reorder_nodes(G, 'community')
# B = nx.to_numpy_array(H)
# # plt.pcolormesh(B)
# plt.imshow(B)
# plt.show()
visualize_graph_matrix(H)
def createGraphsAndCommunities():
g = nx.scale_free_graph(500, alpha=0.40, beta=0.40, gamma=0.20)
g1 = nx.powerlaw_cluster_graph(500, 10, 0.2)
g2 = nx.barabasi_albert_graph(500, 10)
g3 = nx.newman_watts_strogatz_graph(500, 10, 0.2)
nx.write_graphml (g, direc+"sfg.graphml")
nx.write_graphml(g1, direc+"pcg.graphml")
nx.write_graphml(g2, direc+"bag.graphml")
nx.write_graphml(g3, direc+"nwsg.graphml")
graphs = {}
graphs["sfg"] = graph_tool.load_graph(direc+"sfg.graphml")
graphs["pcg"] = graph_tool.load_graph(direc+"pcg.graphml")
graphs["bag"] = graph_tool.load_graph(direc+"bag.graphml")
graphs["nwsg"] = graph_tool.load_graph(direc+"nwsg.graphml")
graphs["price"] = graph_tool.generation.price_network(1000)
for i,h in graphs.iteritems():
s = graph_tool.community.minimize_blockmodel_dl(h)
b = s.b
graph_tool.draw.graph_draw(h, vertex_fill_color=b, vertex_shape=b, output=direc+"block"+str(i)+".pdf")
com = graph_tool.community.community_structure(h, 10000, 20)
graph_tool.draw.graph_draw(h, vertex_fill_color=com, vertex_shape=com, output=direc+"community"+str(i)+".pdf")
state = graph_tool.community.minimize_nested_blockmodel_dl(h)
graph_tool.draw.draw_hierarchy(state, output=direc+"nestedblock"+str(i)+".pdf")
pagerank = graph_tool.centrality.pagerank(h)
graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"pagerank"+str(i)+".pdf")
h.set_reversed(is_reversed=True)
pagerank = graph_tool.centrality.pagerank(h)
graph_tool.draw.graph_draw(h, vertex_fill_color=pagerank, vertex_size = graph_tool.draw.prop_to_size(pagerank, mi=5, ma=15), vorder=pagerank, output=direc+"reversed_pagerank"+str(i)+".pdf")
def connect_newman_watts_strogatz(self,N,k,p):
"""
Newman-Watts-Strogatz graph staring with a k-nearest neighbor ring. Additional edges are added with
probability p.
"""
# ditto
self.connect_empty(N)
self.add_edges_from(nx.newman_watts_strogatz_graph(N,k,p).edges())
def __gen_smallworld_topology(self, nodes):
# Each node is joined with its k nearest neighbors in a ring topology
k = self.__connection_parameter['k']
# The probability of rewiring each edge
p = self.__connection_parameter['p']
# return nx.connected_watts_strogatz_graph(nodes, k, p)
return nx.newman_watts_strogatz_graph(nodes, k, p)
def graphWave(population, neighbors, probability):
g = nx.newman_watts_strogatz_graph(population, neighbors, probability)
model = GraphWave()
model.fit(g)
embedding = model.get_embedding()
#print(embedding)
return [embedding]
def mesh_1d_directed_weighted(n, k):
G=nx.newman_watts_strogatz_graph(n, k, 0, seed=None)
G.to_directed()
for (u,v,w) in G.edges(data=True):
w['weight'] = random.randint(0,1)
return G
def __init__(self, size, meanDegree, beta):
self.size = size
self.meanDegree = meanDegree
self.beta = beta
self.network = nx.newman_watts_strogatz_graph(self.size,self.meanDegree,self.beta) #No edges are removed in newman implementation (So, atleast we get a ring lattice)
# Network stats object
self.networkStats = Networkstats(self.network, self.size)
def directed_newman_watts_strogatz_graph(n, k, p, seed=None):
G = nx.newman_watts_strogatz_graph(n, k, p, seed)
DG = nx.DiGraph()
DG.add_nodes_from(G.nodes())
for (u, v) in G.edges_iter():
r = random.randint(0, 1)
if r == 0:
DG.add_edge(u, v)
else:
DG.add_edge(v, u)
return DG
def RandomNewmanWattsStrogatz(n, k, p, seed=None):
"""
Returns a Newman-Watts-Strogatz small world random graph on n
vertices.
From the NetworkX documentation: First create a ring over n nodes.
Then each node in the ring is connected with its k nearest
neighbors. Then shortcuts are created by adding new edges as
follows: for each edge u-v in the underlying "n-ring with k nearest
neighbors"; with probability p add a new edge u-w with
randomly-chosen existing node w. In contrast with
watts_strogatz_graph(), no edges are removed.
INPUT:
- ``n`` - number of vertices.
- ``k`` - each vertex is connected to its k nearest
neighbors
- ``p`` - the probability of adding a new edge for
each edge
- ``seed`` - for the random number generator
EXAMPLE: We show the edge list of a random graph on 7 nodes with 2
"nearest neighbors" and probability `p = 0.2`::
sage: graphs.RandomNewmanWattsStrogatz(7, 2, 0.2).edges(labels=False)
[(0, 1), (0, 2), (0, 3), (0, 6), (1, 2), (2, 3), (2, 4), (3, 4), (3, 6), (4, 5), (5, 6)]
::
sage: G = graphs.RandomNewmanWattsStrogatz(12, 2, .3)
sage: G.show() # long time
REFERENCE:
- [1] Newman, M.E.J., Watts, D.J. and Strogatz, S.H. Random
graph models of social networks. Proc. Nat. Acad. Sci. USA
99, 2566-2572.
"""
if seed is None:
seed = current_randstate().long_seed()
import networkx
return graph.Graph(networkx.newman_watts_strogatz_graph(n, k, p, seed=seed))
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 small_world():
G = nx.newman_watts_strogatz_graph(n=121, k=4, p=0.05)
G.graph['name'] = 'small_world'
for i in xrange(MAX_ROAD_ATTEMPTS):
n1, n2 = sample(G.nodes(), 2)
if not nx.has_path(G, n1, n2):
continue
sp = nx.shortest_path(G, n1, n2)
index = random.choice(range(len(sp) - 1))
u, v = sp[index], sp[index + 1]
G.remove_edge(u, v)
if not nx.has_path(G, u, v):
G.add_edge(u, v)
continue
G.add_edge(u, v)
set_init_road_path(G, n1, n2, u, v)
return G
def build_topology_smallworld(config):
"""Build a small world network"""
size = config['SmallWorldTopology']['size']
neighbors = config['SmallWorldTopology']['neighbors']
edgeprob = config['SmallWorldTopology']['edgeprob']
seed = config['Simulation']['seed']
assert size > 0
assert neighbors >= 0
assert 0 <= edgeprob <= 1
top = nx.newman_watts_strogatz_graph(n=size, k=neighbors, p=edgeprob,
seed=seed)
top.name = 'Small World network: {s} nodes, {n} neighbors, ' \
'{p} edge probability'.format(s=size, n=neighbors, p=edgeprob)
return top
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 generate_graph(voters):
# generate edges randomly
# n, k, p, [seed]
# n = nodes
ws=nx.newman_watts_strogatz_graph(len(voters),len(voters)/10,1)
G = nx.DiGraph(ws)
for i in range(len(voters)):
G.node[i]['score']=voters[i]['score']
G.node[i]['error']=voters[i]['error']
for (a, b) in G.edges():
G.edge[a][b]['weight'] = generate_rating(voters[a],voters[b])
#nx.draw(G)
#nx.draw_networkx_edge_labels(G,pos=nx.spring_layout(G))
#plt.show()
return G
def correlation_betweenness_degree_on_NW():
n = 1000
k = 4
p = 0.01
G = nx.newman_watts_strogatz_graph(n, k, p)
print nx.info(G)
ND, ND_lambda = ECT.get_number_of_driver_nodes(G)
print "ND = ", ND
print "ND lambda:", ND_lambda
ND, driverNodes = ECT.get_driver_nodes(G)
print "ND =", ND
degrees = []
betweenness = []
tot_degree = nx.degree_centrality(G)
tot_betweenness = nx.betweenness_centrality(G,weight=None)
for node in driverNodes:
degrees.append(tot_degree[node])
betweenness.append(tot_betweenness[node])
with open("results/driver_degree_NW.txt", "w") as f:
for x in degrees:
print >> f, x
with open("results/driver_betweenness_NW.txt", "w") as f:
for x in betweenness:
print >> f, x
with open("results/tot_degree_NW.txt", "w") as f:
for key, value in tot_degree.iteritems():
print >> f, value
with open("results/tot_betweenness_NW.txt", "w") as f:
for key, value in tot_betweenness.iteritems():
print >> f, value
def get_universe():
"""
Creates a universe and returns a dict with important universe information
"""
# Generate a connected network of nodes
G = nx.newman_watts_strogatz_graph(100,2,0.9)
# Assign a 2d position to the nodes
locs = nx.spectral_layout(G)
# Create the Solar Systems by looping though the node list created by networkx
systemlist = {}
for node in G.nodes():
system = dict()
system["name"] = 'Unnamed System SX-%s' % node
dests = []
for dest in G[node]:
dests.append(dest)
system["destinations"] = dests
system["coordinates"] = locs[node]
# Determine security level by distance to node 1
if nx.shortest_path_length(G,source=node, target=1) > 3:
system["security"] = 0
else:
system["security"] = 1
systemlist[node] = system
# Create a security zone from
return systemlist
def generate_model_networks(num_nodes):
networks=[]
#erdos_renyi_graph n
for p in np.arange(0.01, 0.99, 0.01):
G=nx.erdos_renyi_graph(num_nodes,p)
G.name='Erdos p='+str(p)+' nodes='+str(num_nodes)
networks.append(G)
#newman_watts_strogatz_graph
for p in np.arange(0.01, 0.99, 0.01):
for n in np.arange(5,np.min([int(num_nodes/2.0),150]), 20):
G=nx.newman_watts_strogatz_graph(num_nodes,n,p)
G.name='Newman Watts Strogatz p='+str(p)+' n='+str(n)+' nodes='+str(num_nodes)
networks.append(G)
#barabasi
for n in np.arange(5,num_nodes, 5):#np.arange(5,np.min([int(num_nodes/2.0),150]), 20):
G=nx.barabasi_albert_graph(num_nodes,n)
G.name='Barabasi n='+str(n)+' nodes='+str(num_nodes)
networks.append(G)
return networks
def exportRandomGraph(name, path=''):
G = nx.newman_watts_strogatz_graph(6,2,0.5)
nx.draw(G)
plt.savefig('img_rdm_generate_graph_'+name+'.png')
plt.clf()
print(pl.is_planar(G))
def random_symmetric_graph(num_nodes, num_joints, num_colors, rewiring_p=0.5):
"""
random_symmetric_graph(num_nodes, num_joints, num_colors, rewiring_p=0.4):
makes a symmetric (newman-watts-strogatz) graph.
Returns:
nodes, node_centers (in [-1, 1] x [-1, 1]), node_colors, edges
"""
# Make the first graph
connected_graph = False
while not connected_graph:
g = nx.newman_watts_strogatz_graph(num_nodes, 3, rewiring_p)
connected_graph = nx.is_connected(g)
# Make a copy, which we will join to the first graph.
g2 = g.copy()
# Rename all vertices in the second graph except the joints
mapping = dict()
for i in range(num_joints, num_nodes):
mapping[i] = (num_nodes + 1) + i
nx.relabel_nodes(g2, mapping, copy=False)
# TODO: Need a symmetric layout algorithm.
"""
Getting the layout of the one-sided graph (g) before composition, and
reflecting the positions of the other side manually around the LSQ line of
the joints nodes should work.
"""
# Get spring-directed layout of one-sided graph.
g_layout = nx.spring_layout(g, scale=1.0)
# Get the composition of the two graphs
g = nx.compose(g, g2)
# Force-directed graph layout
g_layout = nx.spring_layout(g, k=1 / np.sqrt(g.number_of_nodes()), iterations=1000, fixed=None, scale=1.0)
node_centers = []
for k, v in g_layout.items():
node_centers.append((v[0], v[1]))
# Choose node colors
colors = np.array(
[("red", "blue", "gray")[0:num_colors] for i in range(np.int(np.ceil(g.number_of_nodes() / num_colors)))]
)
colors = colors.flatten()
color_choices = np.random.choice(colors, g.number_of_nodes(), replace=False)
node_colors = []
# Replace string with rgba value.
for i in range(len(color_choices)):
if color_choices[i] == "red":
node_colors.append(COLOR_RED)
elif color_choices[i] == "blue":
node_colors.append(COLOR_BLUE)
elif color_choices[i] == "gray":
node_colors.append(COLOR_GRAY)
return g.nodes(), node_centers, node_colors, g.edges()
#G = nx.read_edgelist(filename,create_using=nx.DiGraph())
#k = 11
#P = [[.902,.253],[.221,.582]]
#G = product.kronecker_random_graph(k,P)
#for u,v in G.selfloop_edges():
# G.remove_edge(u,v)
#G = nx.read_edgelist("C:\\Users\\tweninge\\Downloads\\CA-HepTh.txt")
#G = nx.barabasi_albert_graph(500, 1)
#G = nx.powerlaw_cluster_graph(1000,1,.1)
#G = nx.random_regular_graph(10, 1000)
#G = nx.scale_free_graph(1000)
#G = nx.erdos_renyi_graph(1000,.05)
#G = nx.watts_strogatz_graph(3000, 6, .35)
G = nx.newman_watts_strogatz_graph(250, 4, .05)
#G = nx.newman_watts_strogatz_graph(1000, 5, .25)
G = nx.Graph(G)
A = nx.to_numpy_matrix(G)
u, s, v = np.linalg.svd(A)
f, ((ax1, ax2, ax3), (ax4, ax5, ax6), (ax7, ax8, ax9)) = plt.subplots(3, 3, sharex='col', sharey='row', figsize=(8,8), dpi=80)
ax1.scatter(u[0],u[1])
ax2.scatter(u[1],u[2])
ax3.scatter(u[2],u[3])
ax4.scatter(u[3],u[4])
ax5.scatter(u[4],u[5])
ax6.scatter(u[5],u[6])
import networkx G = networkx.newman_watts_strogatz_graph(100, 3, 0.5)
import networkx as nx
node_ct = 100
graphs = {
"Erdos-Renyi P=0.1": lambda: nx.erdos_renyi_graph(node_ct, 0.1),
"Erdos-Renyi P=0.25": lambda: nx.erdos_renyi_graph(node_ct, 0.25),
"Erdos-Renyi P=0.5": lambda: nx.erdos_renyi_graph(node_ct, 0.5),
"Newman-Watts-Strogatz P=0.1, k=10/node_ct": lambda: nx.newman_watts_strogatz_graph(
node_ct, int(10.0 / node_ct), 0.1
),
"Newman-Watts-Strogatz P=0.25, k=10/node_ct": lambda: nx.newman_watts_strogatz_graph(
node_ct, int(10.0 / node_ct), 0.25
),
"Newman-Watts-Strogatz P=0.5, k=10/node_ct": lambda: nx.newman_watts_strogatz_graph(
node_ct, int(10.0 / node_ct), 0.5
),
"Random Regular - Degree=1": lambda: nx.random_regular_graph(1, node_ct),
"Random Regular - Degree=10": lambda: nx.random_regular_graph(10, node_ct),
"Random Regular - Degree=50": lambda: nx.random_regular_graph(50, node_ct),
"Barabasi Albert - Edges=1": lambda: nx.barabasi_albert_graph(node_ct, 1),
"Barabasi Albert - Edges=10": lambda: nx.barabasi_albert_graph(node_ct, 10),
"Barabasi Albert - Edges=50": lambda: nx.barabasi_albert_graph(node_ct, 50),
}
def EdgeAttackNW():
start_time = time.time()
n = 200
k = 4
p = 0.1
fraction = 0.2
E = 440
E_rm = 88
run_cnt = 100
#******** Run Node Attack 1 ********#
tot_ND1 = [0] * (E_rm + 1)
tot_T1 = [0] * (E_rm + 1)
rndseed = 0
for i in range(run_cnt):
G1 = nx.newman_watts_strogatz_graph(n, k, p, seed=rndseed)
print ">>>>>>>>>>>>>>> Random Attack run time count: ", i + 1, "<<<<<<<<<<<<<<<<<<"
print "graph info", nx.info(G1)
ND1, T1 = RandomEdgeAttack(G1, remove_fraction=fraction)
tot_ND1 = [x + y for x, y in zip(tot_ND1, ND1)]
rndseed += 1
tot_ND1 = [((x + 0.0) / run_cnt) for x in tot_ND1]
tot_T1 = T1
tot_ND1 = [(x + 0.0) / (n + 0.0) for x in tot_ND1]
tot_T1 = [(x + 0.0) / (E + 0.0) for x in tot_T1]
with open("results2/edge_attack1_NW.csv", "w") as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(zip(tot_T1, tot_ND1))
#******** Run Node Attack 2 ********#
tot_ND1 = [0] * (E_rm + 1)
tot_T1 = [0] * (E_rm + 1)
rndseed = 0
for i in range(run_cnt):
G1 = nx.newman_watts_strogatz_graph(n, k, p, seed=rndseed)
print ">>>>>>>>>>>>>>> Initial Degree Attack run time count: ", i + 1, "<<<<<<<<<<<<<<<<<<"
print "graph info", nx.info(G1)
ND1, T1 = InitialEdgeDegreeAttack(G1, remove_fraction=fraction)
tot_ND1 = [x + y for x, y in zip(tot_ND1, ND1)]
rndseed += 1
tot_ND1 = [((x + 0.0) / run_cnt) for x in tot_ND1]
tot_T1 = T1
tot_ND1 = [(x + 0.0) / (n + 0.0) for x in tot_ND1]
tot_T1 = [(x + 0.0) / (E + 0.0) for x in tot_T1]
with open("results2/edge_attack2_NW.csv", "w") as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(zip(tot_T1, tot_ND1))
#******** Run Node Attack 3 ********#
tot_ND1 = [0] * (E_rm + 1)
tot_T1 = [0] * (E_rm + 1)
rndseed = 0
for i in range(run_cnt):
G1 = nx.newman_watts_strogatz_graph(n, k, p, seed=rndseed)
print ">>>>>>>>>>>>>>> Recalculated Degree Attack run time count: ", i + 1, "<<<<<<<<<<<<<<<<<<"
print "graph info", nx.info(G1)
ND1, T1 = RecalculatedEdgeDegreeAttack(G1, remove_fraction=fraction)
tot_ND1 = [x + y for x, y in zip(tot_ND1, ND1)]
rndseed += 1
tot_ND1 = [((x + 0.0) / run_cnt) for x in tot_ND1]
tot_T1 = T1
tot_ND1 = [(x + 0.0) / (n + 0.0) for x in tot_ND1]
tot_T1 = [(x + 0.0) / (E + 0.0) for x in tot_T1]
with open("results2/edge_attack3_NW.csv", "w") as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(zip(tot_T1, tot_ND1))
#******** Run Node Attack 4 ********#
tot_ND1 = [0] * (E_rm + 1)
tot_T1 = [0] * (E_rm + 1)
rndseed = 0
for i in range(run_cnt):
G1 = nx.newman_watts_strogatz_graph(n, k, p, seed=rndseed)
print ">>>>>>>>>>>>>>> Initial Betweenness Attack run time count: ", i + 1, "<<<<<<<<<<<<<<<<<<"
print "graph info", nx.info(G1)
ND1, T1 = InitialEdgeBetweennessAttack(G1, remove_fraction=fraction)
tot_ND1 = [x + y for x, y in zip(tot_ND1, ND1)]
rndseed += 1
tot_ND1 = [((x + 0.0) / run_cnt) for x in tot_ND1]
tot_T1 = T1
tot_ND1 = [(x + 0.0) / (n + 0.0) for x in tot_ND1]
tot_T1 = [(x + 0.0) / (E + 0.0) for x in tot_T1]
with open("results2/edge_attack4_NW.csv", "w") as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(zip(tot_T1, tot_ND1))
#******** Run Node Attack 5 ********#
tot_ND1 = [0] * (E_rm + 1)
tot_T1 = [0] * (E_rm + 1)
rndseed = 0
for i in range(run_cnt):
G1 = nx.newman_watts_strogatz_graph(n, k, p, seed=rndseed)
print ">>>>>>>>>>>>>>> Recalculated Betweenness Attack run time count: ", i + 1, "<<<<<<<<<<<<<<<<<<"
print "graph info", nx.info(G1)
ND1, T1 = RecalculatedEdgeBetweennessAttack(G1, remove_fraction=fraction)
tot_ND1 = [x + y for x, y in zip(tot_ND1, ND1)]
rndseed += 1
tot_ND1 = [((x + 0.0) / run_cnt) for x in tot_ND1]
tot_T1 = T1
tot_ND1 = [(x + 0.0) / (n + 0.0) for x in tot_ND1]
tot_T1 = [(x + 0.0) / (E + 0.0) for x in tot_T1]
with open("results2/edge_attack5_NW.csv", "w") as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(zip(tot_T1, tot_ND1))
print "--- cost time %s seconds ---" %(time.time() - start_time)
[ic, "itertive_compression"],
# [rn, "randomized_opt"], # disabled because too slow
[mif, "maximum_induced_forest"]]
graph = nx.erdos_renyi_graph(9, 0.5)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(10, 0.7)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(11, 0.6)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(12, 0.3)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(13, 0.5)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(15, 0.8)
test_algorithms(algorithms, graph)
graph = nx.erdos_renyi_graph(16, 0.8)
test_algorithms(algorithms, graph)
graph = nx.dense_gnm_random_graph(10, 25)
test_algorithms(algorithms, graph)
graph = nx.newman_watts_strogatz_graph(11, 5, 0.2)
test_algorithms(algorithms, graph)
import pygraphviz as pgv
import networkx as nx
#普通にnetworkxのグラフを作成
h = nx.newman_watts_strogatz_graph(10,3,0.4)
#これをagraphクラス（PyGraphviz）に変換
g = nx.to_agraph(h)
#file.pdfという名前で出力，レイアウトはcircoを使う
g.draw('file.pdf',prog='circo')
def sen(n1, p1, n2, p2, n3, p3, pa, pb):
"""Creates a SEN model with an actor network of n1 elements, with a neighbourhood connectivity of p1, a user network of n2 elements, with a neighbourhood connectivity of p2, and a ecological network of n3 elements with a neighbourhood connectivity of p3. The probability of connections between the actor network and the user netwrok, and between the user network and the ecological network, are respectively passed through pa and pb"""
# Actor network
A = nx.newman_watts_strogatz_graph(n1, p1, 1)
A.graph["Network"] = "Actors"
# Adding id
for i in range(len(A)):
A.node[i]["num"] = i + 1
# Subnetwork
for i in range(len(A)):
A.node[i]["subnetwork"] = 1
# Adding random class (office dwellers/field people)
p_class_bureau = 0.75
for i in range(len(A)):
if random.random() <= p_class_bureau:
A.node[i]["group"] = 0
else:
A.node[i]["group"] = 0
# Adding randow weight
# for n,nbrs in A.adjacency_iter():
# for nbr,eattr in nbrs.items():
# A[n][nbr]['weight'] = int(random.random()*8)
# User network
U = nx.newman_watts_strogatz_graph(n2, p2, 1)
U.graph["Network"] = "Actors"
# Adding id
for i in range(len(U)):
U.node[i]["num"] = i + 1001
# Subnetwork
for i in range(len(U)):
U.node[i]["subnetwork"] = 2
# Adding random class (office dwellers/field people)
for i in range(len(U)):
rnd = random.random()
if rnd <= 0.2:
U.node[i]["group"] = 1
if rnd > 0.2 and rnd <= 0.4:
U.node[i]["group"] = 1
if rnd > 0.4 and rnd <= 0.6:
U.node[i]["group"] = 1
if rnd > 0.6 and rnd <= 0.8:
U.node[i]["group"] = 1
if rnd > 0.8:
U.node[i]["group"] = 1
# Adding randow weight
# for n,nbrs in U.adjacency_iter():
# for nbr,eattr in nbrs.items():
# U[n][nbr]['weight'] = int(random.random()*8)
# Ecological network
E = nx.newman_watts_strogatz_graph(n3, p3, 1)
E.graph["Network"] = "Actors"
# Adding id
for i in range(len(E)):
E.node[i]["num"] = i + 10001
# Subnetwork
for i in range(len(E)):
E.node[i]["subnetwork"] = 3
# Adding class
for i in range(len(E)):
E.node[i]["group"] = 2
# Adding weight
# for n,nbrs in E.adjacency_iter():
# for nbr,eattr in nbrs.items():
# E[n][nbr]['weight'] = 5
# joint the three subnetworks
G = nx.disjoint_union_all([A, U, E])
# link some actors to some users
for i in range(0, len(G)):
for j in range(0, len(G)):
if i != j:
if G.node[i]["subnetwork"] == 1 and G.node[j]["subnetwork"] == 2:
# if G.node[i]['group'] == 1 and G.node[j]['group'] == 2:
if random.random() < pa:
G.add_edge(i, j)
# link some users to some patches
for i in range(0, len(G)):
G.node[i]["degreeold"] = G.degree(i)
for i in range(0, len(G)):
for j in range(0, len(G)):
if i != j:
# print str(j) + " " + str(G.degree(j))
if (
G.node[i]["subnetwork"] == 2
and G.node[j]["subnetwork"] == 3
and G.degree(j) - G.node[j]["degreeold"] < 4
):
if G.degree(j) - G.node[j]["degreeold"] < 4:
if random.random() < pb:
G.add_edge(i, j)
# write json formatted data
d = json_graph.node_link_data(G)
json.dump(d, open("/Users/Rodolphe/Dropbox/Public/d3/examples/force/force.json", "w"))
nx.write_graphml(G, "graph.graphml")
return G
from __future__ import division
import random
import matplotlib.pyplot as plt
import networkx as nx
wsg = nx.newman_watts_strogatz_graph(1000, 3, 0.9)
# wsg = nx.barabasi_albert_graph(5000000, 2)
nx.draw(wsg)
plt.show()
def ExpectBroadcastValue(nk=int(), af=float(), path_list=list()):
start_list = wsg.edge[nk].keys()
s = int(len(start_list) * af)
if s == 0:
return 1
for node in random.sample(start_list, s):
if node not in path_list:
return nk + ExpectBroadcastValue(node, af, path_list)
KOL_list = list()
citizen_list = list()
for k in wsg.edge.iterkeys():
if len(wsg.edge[k]) > 10:
KOL_list.append(k)
elif len(wsg.edge[k]) == 2:
citizen_list.append(k)
results = pd.DataFrame()
for seed in range(0, 5):
# set seed
axl.seed(seed)
num_players = random.randint(2, 132)
# define the graph
players = random.sample(ordinary_players, num_players)
for parameter in range(0, 10) :
p = parameter/100
# Define graph
G = nx.newman_watts_strogatz_graph(len(players), 8, p)
edges = G.edges()
results = results.append([tournament_results(G, seed, p, players, turns,
edges, repetitions)])
results = results[cols]
if not file_exists:
results.to_hdf(write_out, '{}_{}'.format(experiment, num_neighbors),
index=False, header=True)
else :
results.to_hdf(write_out, '{}_{}'.format(experiment, num_neighbors),
mode='a', index=False, header=False)
import networkx G = networkx.newman_watts_strogatz_graph(50, 16, 0.3, seed=None)
