def test_multi(self):
vm = MultiPlot()
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.001)
config.add_model_parameter('gamma', 0.01)
config.add_model_parameter("percentage_infected", 0.05)
model.set_initial_status(config)
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
viz = DiffusionTrend(model, trends)
p = viz.plot()
vm.add_plot(p)
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.001)
config.add_model_parameter('gamma', 0.01)
config.add_model_parameter("percentage_infected", 0.05)
model.set_initial_status(config)
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
viz = DiffusionPrevalence(model, trends)
p1 = viz.plot()
vm.add_plot(p1)
m = vm.plot()
self.assertIsInstance(m, Column)
def synthetic_three_level(n,p1,p2,p3,J_isolates=False,F_isolates=False,D_isolates=False):#,isolate_up=True,isolate_down=True):
k=n
J=nx.erdos_renyi_graph(n,p1) #The first layer graph
Jis = nx.isolates(J)
F=nx.erdos_renyi_graph(n,p2) #The second layer graph
Fis = nx.isolates(F)
D=nx.erdos_renyi_graph(n,p3) #The third layer graph
Dis = nx.isolates(D)
def translation_graph(J,F,D):
H1=nx.Graph()
H2=nx.Graph()
for i in range(n):
H1.add_edges_from([(J.nodes()[i],F.nodes()[i])])
H2.add_edges_from([(F.nodes()[i],D.nodes()[i])])
return H1, H2
Jed = set(J.edges())
Fed = set(F.edges())
Ded = set(D.edges())
l=[Jed,Fed,Ded]
lu = list(set.union(*l))
JFD=nx.Graph()
JFD.add_edges_from(lu)
G=nx.Graph() #The synthetic two-layer graph
# Relabing nodes maps
mappingF={}
for i in range(2*n):
mappingF[i]=n+i
FF=nx.relabel_nodes(F,mappingF,copy=True)
mappingD={}
for i in range(2*n):
if i >n-1:
mappingD[i]=i-n
else:
mappingD[i]=2*n+i
DD=nx.relabel_nodes(D,mappingD,copy=True)
H1, HH2 = translation_graph(J,FF,DD)
G.add_edges_from(J.edges())
G.add_edges_from(H1.edges())
G.add_edges_from(DD.edges())
G.add_edges_from(HH2.edges())
G.add_edges_from(FF.edges())
edgeList = []
for e in H1.edges():
edgeList.append(e)
for e in HH2.edges():
edgeList.append(e)
return G, J, FF, DD, JFD, edgeList
def test_strong_product():
null=nx.null_graph()
empty1=nx.empty_graph(1)
empty10=nx.empty_graph(10)
K2=nx.complete_graph(2)
K3=nx.complete_graph(3)
K5=nx.complete_graph(5)
K10=nx.complete_graph(10)
P2=nx.path_graph(2)
P3=nx.path_graph(3)
P5=nx.path_graph(5)
P10=nx.path_graph(10)
# null graph
G=strong_product(null,null)
assert_true(nx.is_isomorphic(G,null))
# null_graph X anything = null_graph and v.v.
G=strong_product(null,empty10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,K3)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,K10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,P3)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,P10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(empty10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(K3,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(K10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P3,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P5,K3)
assert_equal(nx.number_of_nodes(G),5*3)
G=strong_product(K3,K5)
assert_equal(nx.number_of_nodes(G),3*5)
#No classic easily found classic results for strong product
G = nx.erdos_renyi_graph(10,2/10.)
H = nx.erdos_renyi_graph(10,2/10.)
GH = strong_product(G,H)
for (u_G,u_H) in GH.nodes_iter():
for (v_G,v_H) in GH.nodes_iter():
if (u_G==v_G and H.has_edge(u_H,v_H)) or \
(u_H==v_H and G.has_edge(u_G,v_G)) or \
(G.has_edge(u_G,v_G) and H.has_edge(u_H,v_H)):
assert_true(GH.has_edge((u_G,u_H),(v_G,v_H)))
else:
assert_true(not GH.has_edge((u_G,u_H),(v_G,v_H)))
def create_list_of_adj_mats(n_runs):
adj_mats = []
for i in xrange(n_runs):
# Creating connected adj matrix
net = nx.erdos_renyi_graph(N, link_density)
while len(list(nx.connected_components(net))) > 1:
print "Network has isolated components. Try again!"
net = nx.erdos_renyi_graph(N, link_density)
adj_mats.append(nx.adj_matrix(net).toarray())
return adj_mats
def test_lexicographic_product_random():
G = nx.erdos_renyi_graph(10,2/10.)
H = nx.erdos_renyi_graph(10,2/10.)
GH = lexicographic_product(G,H)
for (u_G,u_H) in GH.nodes_iter():
for (v_G,v_H) in GH.nodes_iter():
if G.has_edge(u_G,v_G) or (u_G==v_G and H.has_edge(u_H,v_H)):
assert_true(GH.has_edge((u_G,u_H),(v_G,v_H)))
else:
assert_true(not GH.has_edge((u_G,u_H),(v_G,v_H)))
def test_tensor_product_random():
G = nx.erdos_renyi_graph(10,2/10.)
H = nx.erdos_renyi_graph(10,2/10.)
GH = tensor_product(G,H)
for (u_G,u_H) in GH.nodes_iter():
for (v_G,v_H) in GH.nodes_iter():
if H.has_edge(u_H,v_H) and G.has_edge(u_G,v_G):
assert_true(GH.has_edge((u_G,u_H),(v_G,v_H)))
else:
assert_true(not GH.has_edge((u_G,u_H),(v_G,v_H)))
def test_cartesian_product_random():
G = nx.erdos_renyi_graph(10,2/10.)
H = nx.erdos_renyi_graph(10,2/10.)
GH = cartesian_product(G,H)
for (u_G,u_H) in GH.nodes_iter():
for (v_G,v_H) in GH.nodes_iter():
if (u_G==v_G and H.has_edge(u_H,v_H)) or \
(u_H==v_H and G.has_edge(u_G,v_G)):
assert_true(GH.has_edge((u_G,u_H),(v_G,v_H)))
else:
assert_true(not GH.has_edge((u_G,u_H),(v_G,v_H)))
def createBridge(numOfNodes, edgeProb, bridgeNodes):
'''
numOfNodes: Number of nodes in the clustered part of the Bridge Graph
edgeProb: Probability of existance of an edge between any two vertices.
bridgeNodes: Number of nodes in the bridge
This function creates a Bridge Graph with 2 main clusters connected by a bridge.
'''
print "Generating and Saving Bridge Network..."
G1 = nx.erdos_renyi_graph(2*numOfNodes + bridgeNodes, edgeProb) #Create an ER graph with number of vertices equal to twice the number of vertices in the clusters plus the number of bridge nodes.
G = nx.Graph() #Create an empty graph so that it can be filled with the required components from G1
G.add_edges_from(G1.subgraph(range(numOfNodes)).edges()) #Generate an induced subgraph of the nodes, ranging from 0 to numOfNodes, from G1 and add it to G
G.add_edges_from(G1.subgraph(range(numOfNodes + bridgeNodes,2*numOfNodes + bridgeNodes)).edges()) #Generate an induced subgraph of the nodes, ranging from (numOfNodes + bridgeNodes) to (2*numOfNodes + bridgeNodes)
A = random.randrange(numOfNodes) #Choose a random vertex from the first component
B = random.randrange(numOfNodes + bridgeNodes,2*numOfNodes + bridgeNodes) #Choose a random vertex from the second component
prev = A #creating a connection from A to B via the bridge nodes
for i in range(numOfNodes, numOfNodes + bridgeNodes):
G.add_edge(prev, i)
prev = i
G.add_edge(i, B)
StrMap = {}
for node in G.nodes():
StrMap[node] = str(node)
G = nx.convert.relabel_nodes(G,StrMap)
filename = "BG_" + str(numOfNodes) + "_" + str(edgeProb) + "_" + str(bridgeNodes) + ".gpickle"
nx.write_gpickle(G,filename)#generate a gpickle file of the learnt graph.
print "Successfully written into " + filename
def compare_graphs(graph):
n = nx.number_of_nodes(graph)
m = nx.number_of_edges(graph)
k = np.mean(list(nx.degree(graph).values()))
erdos = nx.erdos_renyi_graph(n, p=m/float(n*(n-1)/2))
barabasi = nx.barabasi_albert_graph(n, m=int(k)-7)
small_world = nx.watts_strogatz_graph(n, int(k), p=0.04)
print(' ')
print('Compare the number of edges')
print(' ')
print('My network: ' + str(nx.number_of_edges(graph)))
print('Erdos: ' + str(nx.number_of_edges(erdos)))
print('Barabasi: ' + str(nx.number_of_edges(barabasi)))
print('SW: ' + str(nx.number_of_edges(small_world)))
print(' ')
print('Compare average clustering coefficients')
print(' ')
print('My network: ' + str(nx.average_clustering(graph)))
print('Erdos: ' + str(nx.average_clustering(erdos)))
print('Barabasi: ' + str(nx.average_clustering(barabasi)))
print('SW: ' + str(nx.average_clustering(small_world)))
print(' ')
print('Compare average path length')
print(' ')
print('My network: ' + str(nx.average_shortest_path_length(graph)))
print('Erdos: ' + str(nx.average_shortest_path_length(erdos)))
print('Barabasi: ' + str(nx.average_shortest_path_length(barabasi)))
print('SW: ' + str(nx.average_shortest_path_length(small_world)))
print(' ')
print('Compare graph diameter')
print(' ')
print('My network: ' + str(nx.diameter(graph)))
print('Erdos: ' + str(nx.diameter(erdos)))
print('Barabasi: ' + str(nx.diameter(barabasi)))
print('SW: ' + str(nx.diameter(small_world)))
def createBridge(numOfNodes, edgeProb, bridgeNodes):
'''
numOfNodes: Number of nodes in the clustered part of the Bridge Graph
edgeProb: Probability of existance of an edge between any two vertices.
bridgeNodes: Number of nodes in the bridge
This function creates a Bridge Graph with 2 main clusters connected by a bridge.
'''
G1 = nx.erdos_renyi_graph(2*numOfNodes + bridgeNodes, edgeProb) #Create an ER graph with number of vertices equal to twice the number of vertices in the clusters plus the number of bridge nodes.
G = nx.Graph() #Create an empty graph so that it can be filled with the required components from G1
G.add_edges_from(G1.subgraph(range(numOfNodes)).edges()) #Generate an induced subgraph of the nodes, ranging from 0 to numOfNodes, from G1 and add it to G
G.add_edges_from(G1.subgraph(range(numOfNodes + bridgeNodes,2*numOfNodes + bridgeNodes)).edges()) #Generate an induced subgraph of the nodes, ranging from (numOfNodes + bridgeNodes) to (2*numOfNodes + bridgeNodes)
A = random.randrange(numOfNodes) #Choose a random vertex from the first component
B = random.randrange(numOfNodes + bridgeNodes,2*numOfNodes + bridgeNodes) #Choose a random vertex from the second component
prev = A #creating a connection from A to B via the bridge nodes
for i in range(numOfNodes, numOfNodes + bridgeNodes):
G.add_edge(prev, i)
prev = i
G.add_edge(i, B)
fout = open("BG_" + str(2*numOfNodes + bridgeNodes) + "_" + str(edgeProb) + ".graph", 'w') #create a file handler and open the corresponding file in write mode
string = pickle.dumps(G) #Convert the generated graph into the string and store it into a file. It is later retrieved in the main module
fout.write(string) #write the string into the file and close the file handler
fout.close()
print "Bridge Graph successfully generated and written into the file."
print "File Name: ", "BG_" + str(2*numOfNodes + bridgeNodes) + "_" + str(edgeProb) + ".graph"
print "Undergoing Machine Learning..."
reinforce(G,"BG", edgeProb) #Enforce Machine Learning to generate two files
def initialize_graph(size):
points_x = []
points_y = []
terminals = []
for i in range(size):
points_x.append(random.uniform(-100, 100))
points_y.append(random.uniform(-100, 100))
for i in range(size):
if i % 2 == 0:
terminals.append(i)
h = nx.erdos_renyi_graph(size, 0.3)
g = nx.Graph()
for i in range(size):
g.add_node(i)
for i in range(size):
for j in range(i, size):
if h.has_edge(i, j):
g.add_edge(i, j)
# weight=manhattan_distance((points_x[i], points_y[i]), (points_x[j], points_y[j])))
length_shortest_paths = nx.all_pairs_dijkstra_path_length(g)
shortest_paths = nx.all_pairs_shortest_path(g)
metric_closure = nx.Graph()
for i in range(size):
metric_closure.add_node(i)
for i in range(size):
for j in range(size):
metric_closure.add_edge(i, j, weight=length_shortest_paths[i][j])
print metric_closure
return (terminals, shortest_paths, metric_closure, points_x, points_y, g)
def get_sim_setting() :
g = nx.erdos_renyi_graph( 10, .3 )
g = nx.connected_component_subgraphs( g )[0]
roadnet = nx.MultiDiGraph()
def roadmaker() :
for i in itertools.count() : yield 'road%d' % i, np.random.exponential()
road_iter = roadmaker()
for i, ( u,v,data ) in enumerate( g.edges_iter( data=True ) ) :
label, length = road_iter.next()
roadnet.add_edge( u, v, label, length=length )
rates = nx.DiGraph()
ROADS = [ key for u,v,key in roadnet.edges_iter( keys=True ) ]
for i in range(5) :
r1 = random.choice( ROADS )
r2 = random.choice( ROADS )
if not rates.has_edge( r1, r2 ) :
rates.add_edge( r1, r2, rate=0. )
data = rates.get_edge_data( r1, r2 )
data['rate'] += .25 * (1./5) * np.random.exponential()
return roadnet, rates
def test_dyn_node_stochastic(self):
dg = dn.DynGraph()
for t in past.builtins.xrange(0, 3):
g = nx.erdos_renyi_graph(200, 0.05)
dg.add_interactions_from(g.edges(), t)
model = gc.DynamicCompositeModel(dg)
model.add_status("Susceptible")
model.add_status("Infected")
model.add_status("Removed")
c1 = cpm.NodeStochastic(0.02, "Infected")
c2 = cpm.NodeStochastic(0.01)
c3 = cpm.NodeStochastic(0.5)
model.add_rule("Susceptible", "Infected", c1)
model.add_rule("Infected", "Removed", c2)
model.add_rule("Infected", "Susceptible", c3)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.execute_snapshots()
self.assertEqual(len(iterations), 3)
iterations = model.execute_iterations()
trends = model.build_trends(iterations)
self.assertEqual(len(trends[0]['trends']['status_delta'][1]),
len([x for x in dg.stream_interactions() if x[2] == "+"]))
def spread_size_distribution_vs_time():
probabilities = [float(i) / 10. for i in range(2, 7)]
graph = sm.SISModel.get_opera_graph()
seed = sm.SISModel.get_random_seed(graph, 100)
for t in [1, 5, 10]:
time_series = []
for i in xrange(len(probabilities)):
model = sm.SISModel(graph, seed, probabilities[i], t, True, 100)
model.spread()
time_series.append(model.get_time_series())
print(time_series)
sm.SISModel.plot_spread_size_distribution(
xrange(len(time_series[0])),
time_series,
['blue', 'red', 'green', 'orange', 'black'],
sm.SISModel.get_data_dir()
+ sm.SISModel.RESULT_DIR
+ 'o_spread_size_distribution_time_series_t{}.png'.format(str(t)),
't, steps'
)
graph = nx.barabasi_albert_graph(4604, 11)
seed = sm.SISModel.get_random_seed(graph, 100)
for t in [1, 5, 10]:
time_series = []
for i in xrange(len(probabilities)):
model = sm.SISModel(graph, seed, probabilities[i], t, True, 100)
model.spread()
time_series.append(model.get_time_series())
print(time_series)
sm.SISModel.plot_spread_size_distribution(
xrange(len(time_series[0])),
time_series,
['blue', 'red', 'green', 'orange', 'black'],
sm.SISModel.get_data_dir()
+ sm.SISModel.RESULT_DIR
+ 'ba_spread_size_distribution_time_series_t{}.png'.format(str(t)),
't, steps'
)
graph = nx.erdos_renyi_graph(4604, 0.0047)
seed = sm.SISModel.get_random_seed(graph, 100)
for t in [1, 5, 10]:
time_series = []
for i in xrange(len(probabilities)):
model = sm.SISModel(graph, seed, probabilities[i], t, True, 100)
model.spread()
time_series.append(model.get_time_series())
print(time_series)
sm.SISModel.plot_spread_size_distribution(
xrange(len(time_series[0])),
time_series,
['blue', 'red', 'green', 'orange', 'black'],
sm.SISModel.get_data_dir()
+ sm.SISModel.RESULT_DIR
+ 'er_spread_size_distribution_time_series_t{}.png'.format(str(t)),
't, steps'
)
def spread_size_distribution_vs_probability():
probabilities = [float(i) / 100. for i in range(100)]
t = 1
graph = sm.SISModel.get_opera_graph()
seed = sm.SISModel.get_random_seed(graph, 100)
print(seed)
o_sizes = []
for i in xrange(len(probabilities)):
print(probabilities[i])
o_sizes.append(sm.SISModel(graph, seed, probabilities[i], t).spread())
print(o_sizes)
graph = nx.barabasi_albert_graph(4604, 11)
seed = sm.SISModel.get_random_seed(graph, 100)
ba_sizes = []
for i in xrange(len(probabilities)):
ba_sizes.append(sm.SISModel(graph, seed, probabilities[i], t).spread())
print(ba_sizes)
graph = nx.erdos_renyi_graph(4604, 0.0047)
seed = sm.SISModel.get_random_seed(graph, 100)
er_sizes = []
for i in xrange(len(probabilities)):
er_sizes.append(sm.SISModel(graph, seed, probabilities[i], t).spread())
print(er_sizes)
sm.SISModel.plot_spread_size_distribution(
probabilities,
[o_sizes, ba_sizes, er_sizes],
['blue', 'black', 'red'],
sm.SISModel.get_data_dir() + sm.SISModel.RESULT_DIR + 'spread_size_distribution.png',
'p'
)
def __init__(self, name, para1, para2):
if name == "PAM":
# nodes, edges, and nodes > edges
self.G = nx.barabasi_albert_graph(para1, para2)
# nodes, prob
elif name == "ER":
self.G = nx.erdos_renyi_graph(para1, para2)
def __init__(self, size, probability):
self.size = size
self.probability = probability
self.network = nx.erdos_renyi_graph(self.size, self.probability, directed=False)
# Network stats object
self.networkStats = Networkstats(self.network, self.size)
def get_sim_setting( N=10, p=.3, mu=1., K=5, lam=1. ) :
"""
get largest connected component of Erdos(N,p) graph
with exponentially distr. road lengths (avg. mu);
Choose k road pairs randomly and assign intensity randomly,
exponential lam
"""
g = nx.erdos_renyi_graph( N, p )
g = nx.connected_component_subgraphs( g )[0]
roadnet = nx.MultiDiGraph()
def roadmaker() :
for i in itertools.count() : yield 'road%d' % i, np.random.exponential( mu )
road_iter = roadmaker()
for i, ( u,v,data ) in enumerate( g.edges_iter( data=True ) ) :
label, length = road_iter.next()
roadnet.add_edge( u, v, label, length=length )
rates = nx.DiGraph()
ROADS = [ key for u,v,key in roadnet.edges_iter( keys=True ) ]
for i in range( K ) :
r1 = random.choice( ROADS )
r2 = random.choice( ROADS )
if not rates.has_edge( r1, r2 ) :
rates.add_edge( r1, r2, rate=0. )
data = rates.get_edge_data( r1, r2 )
data['rate'] += np.random.exponential( lam )
return roadnet, rates
def generate_graph(n, expected_degree, model="ba"):
"""
Generates a graph with a given model and expected_mean
degree
:param n: int Number of nodes of the graph
:param expected_degree: int Expected mean degree
:param model: string Model (ba, er, or ws)
:return: networkx graph
"""
global m
global ws_p
g = None
if model == "ba":
# BA expected avg. degree? m = ba_mean_degrees()
if m is None:
m = ba_mean_degrees(n, expected_degree)
g = nx.barabasi_albert_graph(n, m, seed=None)
if model == "er":
# ER expected avg. degree: d = p*(n-1)
p = float(expected_degree) / float(n - 1)
g = nx.erdos_renyi_graph(n, p, seed=None, directed=False)
if model == "ws":
# WS expected degree == k
g = nx.watts_strogatz_graph(n, expected_degree, ws_p)
return g
def generateRandomNetworks(randomSeed=622527):
seed(randomSeed)
# Network size will be 10^1, 10 ^2, 10^3, 10^4
for exponent in range(1, 4): # 1 .. 4
n = 10 ** exponent
for p in [0.1, 0.3, 0.5, 0.7, 0.9]:
m = round(n * p)
# Generate erdos Renyi networks
graph = nx.erdos_renyi_graph(n, p, randomNum())
graphName = "erdos_renyi_n{}_p{}.graph6".format(n, p)
nx.write_graph6(graph, directory + graphName)
# Generate Barabasi Albert networks
graph = nx.barabasi_albert_graph(n, m, randomNum())
graphName = "barabasi_albert_n{}_m{}.graph6".format(n, m)
nx.write_graph6(graph, directory + graphName)
for k in [0.1, 0.3, 0.5, 0.7, 0.9]:
k = round(n * k)
# Generate Watts Strogatz networks
graph = nx.watts_strogatz_graph(n, k, p, randomNum())
graphName = "watts_strogatz_n{}_k{}_p{}.graph6".format(n, k, p)
nx.write_graph6(graph, directory + graphName)
def __init__(self, num_nodes=10, avg_node_degree=3, initial_outbreak_size=1, virus_spread_chance=0.4,
virus_check_frequency=0.4, recovery_chance=0.3, gain_resistance_chance=0.5):
self.num_nodes = num_nodes
prob = avg_node_degree / self.num_nodes
self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob)
self.grid = NetworkGrid(self.G)
self.schedule = RandomActivation(self)
self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes
self.virus_spread_chance = virus_spread_chance
self.virus_check_frequency = virus_check_frequency
self.recovery_chance = recovery_chance
self.gain_resistance_chance = gain_resistance_chance
self.datacollector = DataCollector({"Infected": number_infected,
"Susceptible": number_susceptible,
"Resistant": number_resistant})
# Create agents
for i, node in enumerate(self.G.nodes()):
a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency,
self.recovery_chance, self.gain_resistance_chance)
self.schedule.add(a)
# Add the agent to the node
self.grid.place_agent(a, node)
# Infect some nodes
infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size)
for a in self.grid.get_cell_list_contents(infected_nodes):
a.state = State.INFECTED
self.running = True
self.datacollector.collect(self)
def init():
global op1, op2, grouping, network, adj_mat
op1 = [(-1 + 2 * random.random()) for agents in range(no_of_agents)]
op2 = [(-1 + 2 * random.random()) for agents in range(no_of_agents)]
grouping = [random.randint(1,m) for agents in range(no_of_agents)]
network = nx.erdos_renyi_graph(no_of_agents,p)
adj_mat = nx.adjacency_matrix(network)
def test_bad_graph_input(self) :
"""modularity is only defined with undirected graph"""
g = nx.erdos_renyi_graph(50, 0.1, directed=True)
part = dict([])
for node in g :
part[node] = 0
self.assertRaises(TypeError, co.modularity, part, g)
def get_random_graph():
G = nx.erdos_renyi_graph(100, 0.1)
H = nx.Graph()
for u,v in G.edges():
d = random.uniform(1,10)
H.add_edge(u, v, weight=d)
return H
def gen_erdos(n,m):
"""
The expected number of edges in an Erdos-Renyi graph
is m = p*n*(n-1)/2
"""
p = 2*m/(n*(n-1))
return nx.erdos_renyi_graph(n,p,directed=True)
def q1():
lada = nx.read_gml("../../data/network_analysis/LadaFacebookAnon.gml")
print_stats(lada, "LadaFacebookAnon")
p = compute_edge_creation_probability(
lada.number_of_nodes(), lada.number_of_edges())
erg = nx.erdos_renyi_graph(lada.number_of_nodes(), p)
print_stats(erg, "Erdos-Renyi Random")
def q2():
gnutella = read_gdf("../../data/network_analysis/gnutella2.gdf")
print_stats(gnutella, "Gnutella")
p = compute_edge_creation_probability(
gnutella.number_of_nodes(), gnutella.number_of_edges())
erg = nx.erdos_renyi_graph(gnutella.number_of_nodes(), p)
print_stats(erg, "Erdos-Renyi Random")
def test_directed_havel_hakimi():
# Test range of valid directed degree sequences
n, r = 100, 10
p = 1.0 / r
for i in range(r):
G1 = nx.erdos_renyi_graph(n, p * (i + 1), None, True)
din1 = list(d for n, d in G1.in_degree())
dout1 = list(d for n, d in G1.out_degree())
G2 = nx.directed_havel_hakimi_graph(din1, dout1)
din2 = list(d for n, d in G2.in_degree())
dout2 = list(d for n, d in G2.out_degree())
assert_equal(sorted(din1), sorted(din2))
assert_equal(sorted(dout1), sorted(dout2))
# Test non-graphical sequence
dout = [1000, 3, 3, 3, 3, 2, 2, 2, 1, 1, 1]
din = [103, 102, 102, 102, 102, 102, 102, 102, 102, 102]
assert_raises(nx.exception.NetworkXError,
nx.directed_havel_hakimi_graph, din, dout)
# Test valid sequences
dout = [1, 1, 1, 1, 1, 2, 2, 2, 3, 4]
din = [2, 2, 2, 2, 2, 2, 2, 2, 0, 2]
G2 = nx.directed_havel_hakimi_graph(din, dout)
dout2 = (d for n, d in G2.out_degree())
din2 = (d for n, d in G2.in_degree())
assert_equal(sorted(dout), sorted(dout2))
assert_equal(sorted(din), sorted(din2))
# Test unequal sums
din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
assert_raises(nx.exception.NetworkXError,
nx.directed_havel_hakimi_graph, din, dout)
# Test for negative values
din = [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -2]
assert_raises(nx.exception.NetworkXError,
nx.directed_havel_hakimi_graph, din, dout)
def sampleroadnet( n=10, p=.3, n_oneway=0 ) :
# based on Erdos Renyi ; n=# of nodes, p=probability any two nodes are linked
g = nx.erdos_renyi_graph( n, p )
# ...then just get the biggest connected component
g = nx.connected_component_subgraphs( g )[0]
# create a roadnet with such connectivity and random street lengths
roadnet = nx.MultiDiGraph()
def roadmaker() :
for i in itertools.count() : yield 'road%d' % i, np.random.exponential()
road_iter = roadmaker()
for i, ( u,v,data ) in enumerate( g.edges_iter( data=True ) ) :
label, length = road_iter.next()
roadnet.add_edge( u, v, label, length=length )
# add some random one-way roads
nodes = roadnet.nodes()
for i in range( n_oneway ) :
u = random.choice( nodes )
v = random.choice( nodes )
label, length = road_iter.next()
roadnet.add_edge( u, v, label, length=length, oneway=True )
return roadnet
def iterated_test(seed=None, testparams=None, params=None):
import algorithms
print 'Starting iterative replication test...'
if seed == None:
seed = npr.randint(1E6)
print 'Setting random number generator seed: %d'%seed
random.seed(seed)
npr.seed(seed)
if params == None:
params = {}
defparams = {'edge_edit_rate':[0.05, 0.05], 'node_edit_rate':[0.05, 0.05], 'verbose':False, }
defparams.update(params)
params = defparams
print 'params'
print params
if testparams == None:
testparams = {}
if 'G' not in testparams:
nn = 1000
p = 0.01
G = nx.erdos_renyi_graph(nn, p)
G.add_edges_from(nx.path_graph(nn).edges())
else:
G = testparams['G']
alg = testparams.get('algorithm', algorithms.generate_graph)
num_rounds = testparams.get('num_rounds', 10)
print 'Round: 1. Initial graph ' + getattr(G, 'name', '_')
for trial in xrange(2, num_rounds+1):
new_G = alg(original=G, params=params)
seed = npr.randint(1E6)
print 'Round: %d. New seed: %d'%(trial,seed)
random.seed(seed)
npr.seed(seed)
print 'PASSED'
#usr/bin/env python
#-*- coding:UTF-8 -*-
#author@blue
#time:2019.07.31
#generate a graph and show
import numpy as np
import random
import networkx as nx
from IPython.display import Image
import matplotlib.pyplot as plt
# Generate the graph
n = 70
p = 0.2
G_erdos = nx.erdos_renyi_graph(n, p, seed=100)
# Plot the graph
plt.figure(figsize=(12, 8))
nx.draw(G_erdos, node_size=10)
fig = plt.gcf()
plt.show()
fig.savefig('a generate graph1.png', dpi=100)
print('that is generate graph and nice')
def ER_graph(node_num, prob): ## unweighted
G = nx.erdos_renyi_graph(node_num, prob)
adj = nx.to_numpy_matrix(G)
adj = np.asarray(adj)
#adj=adj+np.identity(node_num)
return adj
def basic_operation():
# Create a graph.
G = nx.Graph()
# Nodes.
G.add_node(1)
G.add_nodes_from([2, 3])
H = nx.path_graph(10) # Creates a graph.
G.add_nodes_from(H)
G.add_node(H)
#print('G.nodes =', G.nodes)
print('G.nodes =', list(G.nodes))
# Edges.
G.add_edge(1, 2)
e = (2, 3)
G.add_edge(*e) # Unpack edge tuple.
G.add_edges_from([(1, 2), (1, 3)])
G.add_edges_from(H.edges)
#print('G.edges =', G.edges)
print('G.edges =', list(G.edges))
# Remove all nodes and edges.
G.clear()
#--------------------
G.add_edges_from([(1, 2), (1, 3)])
G.add_node(1)
G.add_edge(1, 2)
G.add_node('spam') # Adds node 'spam'.
G.add_nodes_from('spam') # Adds 4 nodes: 's', 'p', 'a', 'm'.
G.add_edge(3, 'm')
print('G.number_of_nodes() =', G.number_of_nodes())
print('G.number_of_edges() =', G.number_of_edges())
# Set-like views of the nodes, edges, neighbors (adjacencies), and degrees of nodes in a graph.
print('G.adj[1] =', list(G.adj[1])) # or G.neighbors(1).
print('G.degree[1] =', G.degree[1]) # The number of edges incident to 1.
# Report the edges and degree from a subset of all nodes using an nbunch.
# An nbunch is any of: None (meaning all nodes), a node, or an iterable container of nodes that is not itself a node in the graph.
print("G.edges([2, 'm']) =", G.edges([2, 'm']))
print('G.degree([2, 3]) =', G.degree([2, 3]))
# Remove nodes and edges from the graph in a similar fashion to adding.
G.remove_node(2)
G.remove_nodes_from('spam')
print('G.nodes =', list(G.nodes))
G.remove_edge(1, 3)
# When creating a graph structure by instantiating one of the graph classes you can specify data in several formats.
G.add_edge(1, 2)
H = nx.DiGraph(G) # Creates a DiGraph using the connections from G.
print('H.edges() =', list(H.edges()))
edgelist = [(0, 1), (1, 2), (2, 3)]
H = nx.Graph(edgelist)
#--------------------
# Access edges and neighbors.
print('G[1] =', G[1]) # Same as G.adj[1].
print('G[1][2] =', G[1][2]) # Edge 1-2.
print('G.edges[1, 2] =', G.edges[1, 2])
# Get/set the attributes of an edge using subscript notation if the edge already exists.
G.add_edge(1, 3)
G[1][3]['color'] = 'blue'
G.edges[1, 2]['color'] = 'red'
# Fast examination of all (node, adjacency) pairs is achieved using G.adjacency(), or G.adj.items().
# Note that for undirected graphs, adjacency iteration sees each edge twice.
FG = nx.Graph()
FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
for n, nbrs in FG.adj.items():
for nbr, eattr in nbrs.items():
wt = eattr['weight']
if wt < 0.5: print(f'({n}, {nbr}, {wt:.3})')
# Convenient access to all edges is achieved with the edges property.
for (u, v, wt) in FG.edges.data('weight'):
if wt < 0.5: print(f'({u}, {v}, {wt:.3})')
#--------------------
# Attributes.
# Graph attributes.
G = nx.Graph(day='Friday')
print('G.graph =', G.graph)
G.graph['day'] = 'Monday'
# Node attributes: add_node(), add_nodes_from(), or G.nodes.
G.add_node(1, time='5pm')
G.add_nodes_from([3], time='2pm')
print('G.nodes[1] =', G.nodes[1])
G.nodes[1]['room'] = 714
print('G.nodes.data() =', G.nodes.data())
# Edge attributes: add_edge(), add_edges_from(), or subscript notation.
G.add_edge(1, 2, weight=4.7)
G.add_edges_from([(3, 4), (4, 5)], color='red')
G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])
G[1][2]['weight'] = 4.7
G.edges[3, 4]['weight'] = 4.2
print('G.edges.data() =', G.edges.data())
#--------------------
# Directed graphs.
DG = nx.DiGraph()
DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
print("DG.out_degree(1, weight='weight') =", DG.out_degree(1, weight='weight'))
print("DG.degree(1, weight='weight') =", DG.degree(1, weight='weight')) # The sum of in_degree() and out_degree().
print('DG.successors(1) =', list(DG.successors(1)))
print('DG.neighbors(1) =', list(DG.neighbors(1)))
# Convert G to undirected graph.
#H = DG.to_undirected()
H = nx.Graph(DG)
#--------------------
# Multigraphs: Graphs which allow multiple edges between any pair of nodes.
MG = nx.MultiGraph()
#MDG = nx.MultiDiGraph()
MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
print("MG.degree(weight='weight') =", dict(MG.degree(weight='weight')))
GG = nx.Graph()
for n, nbrs in MG.adjacency():
for nbr, edict in nbrs.items():
minvalue = min([d['weight'] for d in edict.values()])
GG.add_edge(n, nbr, weight = minvalue)
print('nx.shortest_path(GG, 1, 3) =', nx.shortest_path(GG, 1, 3))
#--------------------
# Classic graph operations:
"""
subgraph(G, nbunch): induced subgraph view of G on nodes in nbunch
union(G1,G2): graph union
disjoint_union(G1,G2): graph union assuming all nodes are different
cartesian_product(G1,G2): return Cartesian product graph
compose(G1,G2): combine graphs identifying nodes common to both
complement(G): graph complement
create_empty_copy(G): return an empty copy of the same graph class
to_undirected(G): return an undirected representation of G
to_directed(G): return a directed representation of G
"""
#--------------------
# Graph generators.
# Use a call to one of the classic small graphs:
petersen = nx.petersen_graph()
tutte = nx.tutte_graph()
maze = nx.sedgewick_maze_graph()
tet = nx.tetrahedral_graph()
# Use a (constructive) generator for a classic graph:
K_5 = nx.complete_graph(5)
K_3_5 = nx.complete_bipartite_graph(3, 5)
barbell = nx.barbell_graph(10, 10)
lollipop = nx.lollipop_graph(10, 20)
# Use a stochastic graph generator:
er = nx.erdos_renyi_graph(100, 0.15)
ws = nx.watts_strogatz_graph(30, 3, 0.1)
ba = nx.barabasi_albert_graph(100, 5)
red = nx.random_lobster(100, 0.9, 0.9)
#--------------------
# Read a graph stored in a file using common graph formats, such as edge lists, adjacency lists, GML, GraphML, pickle, LEDA and others.
nx.write_gml(red, 'path.to.file')
mygraph = nx.read_gml('path.to.file')
for node in graph.nodes():
if graph.degree(node) > maxDegree:
maxDegree = graph.degree(node)
if graph.degree(node) < minDegree:
minDegree = graph.degree(node)
print("Max graph", num, "degree:", maxDegree)
print("Min graph", num, "degree:", minDegree)
return [minDegree, maxDegree]
# Task 1: Given code generating three graphs, compute the degree for each node and
# report the highest and lowest degree over all nodes for each graph
graph1 = nx.barabasi_albert_graph(30, 4)
nx.draw(graph1, with_labels=True)
plt.show()
graph2 = nx.erdos_renyi_graph(30, 0.15)
nx.draw(graph2, with_labels=True)
plt.show()
graph3 = nx.complete_bipartite_graph(3, 5)
nx.draw(graph3, with_labels=True)
plt.show()
minMaxDegree(graph1, 1)
minMaxDegree(graph2, 2)
minMaxDegree(graph3, 3)
# Task 2: Create a directional graph with 5 nodes, 10 edges, and at least
# one node with a single outgoing edge and no incoming edges
DG = nx.DiGraph()
newnodes = (1,2,3,4,5)
def setUp(self) -> None:
self.graphs = [
nx.erdos_renyi_graph(1000, 0.2),
nx.erdos_renyi_graph(1000, 0.5)
]
def randomGraphErdos(N, P):
G = nx.erdos_renyi_graph(N, P)
while (nx.is_connected(G) != True):
G = nx.erdos_renyi_graph(N, P)
return G
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx
from sklearn.cluster import KMeans, AgglomerativeClustering, SpectralClustering
import community as community_louvain
G = nx.erdos_renyi_graph(100, 0.5)
def spectralPartitioning(G, n=None, **kwargs):
mat = nx.to_numpy_matrix(G)
if n is None:
model = SpectralClustering(affinity="precomputed", **kwargs)
else:
model = SpectralClustering(n, affinity="precomputed", **kwargs)
fit = model.fit(mat)
return {n: fit.labels_[i] for i, n in enumerate(G.nodes())}
def hierarchicalPartitioning(G, n=None, **kwargs):
mat = nx.to_numpy_matrix(G)
if n is None:
model = AgglomerativeClustering(**kwargs)
else:
model = AgglomerativeClustering(n, **kwargs)
fit = model.fit(mat)
return {n: fit.labels_[i] for i, n in enumerate(G.nodes())}
def kMeansPartitioning(G, n, **kwargs):
mat = nx.to_numpy_matrix(G)
def get_Erdos_Renyi(Nodes, density):
G = nx.erdos_renyi_graph(Nodes, density)
return (G)
def create_ER_bipartite_graph(N, p):
g = nx.erdos_renyi_graph(N, p)
alist = g.degree().values()
blist = create_blist(alist)
return nx.bipartite.configuration_model(alist, blist.astype(int))
import networkx as nx
import numpy as np
n = 2**10
#n=10
cnct_prob = 4 / n
G = nx.erdos_renyi_graph(n, cnct_prob)
edge_list = []
for line in nx.generate_edgelist(G, data=False):
edge_list.append(line)
#nx.write_edgelist(graph,"input_matrix.txt")
f = open('input_matrix.txt', 'w')
time = 0
times = []
for i in range(2 * n):
#print (i)
time += np.random.exponential(1)
times.append(time)
edge = np.random.choice(edge_list)
#string = str(i) + ": " + edge + ' ' +str(time) + '\n'
string = edge + ' ' + str(time) + '\n'
print(string)
f.write(string)
times = np.array(times)
#diffs = np.diff(times)
m = np.mean(times)
s = np.std(times)
b = (s - m) / (s + m)
print(b)
generate.py a program to generate a random graph's exponential.
Usage:
python generate.py number_of_nodes matrix_file exponential_file
"""
from sys import argv
from networkx import erdos_renyi_graph, to_scipy_sparse_matrix
from scipy.linalg import funm
from scipy.io import mmwrite
from scipy.sparse import csr_matrix
from numpy import exp
###############################################################################
if __name__ == "__main__":
# Generate a random directed graph
nodes = int(argv[1])
prob = 0.05
graph = erdos_renyi_graph(nodes, prob, directed=True)
matrix = to_scipy_sparse_matrix(graph).todense()
for i in range(0, matrix.shape[0]):
for j in range(0, matrix.shape[1]):
if matrix[i, j] != 0 and matrix[j, i] != 0:
matrix[i, j] = 0
# Compute The Exponential
emat = funm(matrix, lambda x: exp(x))
# Write To File
mmwrite(argv[2], csr_matrix(matrix * 1.0))
mmwrite(argv[3], csr_matrix(emat))
V, N, K = get_args()
seed = 3
np.random.seed(seed)
name = "adjacency-N{}-K{}".format(V, K)
with h5py.File('data/' + name + '.h5', 'w') as h5_file:
feature_shape = (2 * N, V, V)
labels_shape = (2 * N, )
features_df = h5_file.create_dataset('features', shape=feature_shape)
labels_df = h5_file.create_dataset('labels', shape=labels_shape)
data = []
labels = []
for n in tqdm(range(2 * N)):
g = nx.erdos_renyi_graph(V, 0.5, seed=seed * n)
print list(g.edges)
if n < N:
labels_df[n] = 0
else:
add_random_k_clique(g, K) # Add K clique in the graph
labels_df[n] = 1
features_df[n] = nx.adjacency_matrix(g).todense()
#!/usr/bin/python
import networkx as nx
import random
import sys
r = random
G = nx.erdos_renyi_graph(int(sys.argv[1]), float(sys.argv[2]),
int(sys.argv[3]))
nx.write_adjlist(G, "tmp")
"""edges=G.edges()
for edge in edges:
ran=r.randint(0,1)
(u,v)=edge
if ran==0:
G.remove_edge(u,v)
else:
G.remove_edge(v,u)"""
g = nx.read_adjlist("tmp", create_using=nx.DiGraph())
C = nx.condensation(g)
nx.write_adjlist(C, "erg")
#G=nx.powerlaw_cluster_graph(100000,200,0.3)
#nx.write_adjlist(G, "powerlowc")
# Calculate the degree of each node: G.node[n]['degree']
G.node[n]['degree'] = nx.degree(G, n)
# Create the CircosPlot object: c
# c = CircosPlot(G, node_order='degree',
# node_grouping='grouping', node_color='grouping')
c = CircosPlot(G, node_order='degree')
# Draw the CircosPlot object to the screen
c.draw()
plt.show()
"""
################# Finding Cliques
G = nx.erdos_renyi_graph(n=57, p=0.67, seed=123)
# Calculate the maximal cliques in G: cliques
cliques = nx.find_cliques(G)
# Count and print the number of maximal cliques in G
print(len(list(cliques)))
# Plotting the cliques
# Find the nodes that are part of the largest maximal clique: largest_clique
largest_clique = sorted(nx.find_cliques(G), key=lambda x: len(x))[-1]
print(len(largest_clique))
# Create the subgraph of the largest_clique: G_lc
G_lc = G.subgraph(largest_clique)
# Create the CircosPlot object: c
if args.dump:
results_dir = r'results/mutualistic/' + args.network
makedirs(results_dir)
# Build network # A: Adjacency matrix, L: Laplacian Matrix, OM: Base Operator
n = args.n # e.g nodes number 400
N = int(np.ceil(np.sqrt(n))) # grid-layout pixels :20
seed = args.seed
if args.network == 'grid':
print("Choose graph: " + args.network)
A = grid_8_neighbor_graph(N)
G = nx.from_numpy_array(A.numpy())
elif args.network == 'random':
print("Choose graph: " + args.network)
G = nx.erdos_renyi_graph(n, 0.1, seed=seed)
G = networkx_reorder_nodes(G, args.layout)
A = torch.FloatTensor(nx.to_numpy_array(G))
elif args.network == 'power_law':
print("Choose graph: " + args.network)
G = nx.barabasi_albert_graph(n, 5, seed=seed)
G = networkx_reorder_nodes(G, args.layout)
A = torch.FloatTensor(nx.to_numpy_array(G))
elif args.network == 'small_world':
print("Choose graph: " + args.network)
G = nx.newman_watts_strogatz_graph(400, 5, 0.5, seed=seed)
G = networkx_reorder_nodes(G, args.layout)
A = torch.FloatTensor(nx.to_numpy_array(G))
elif args.network == 'community':
print("Choose graph: " + args.network)
n1 = int(n / 3)
def Plague(G=None,
Gtype='erdos',
erdosval=0.15,
node_num=50,
mode='Game',
ethics='Good',
difficulty='Brutal',
starttype='random',
starters=None,
numstarters=4,
vaccines='on',
quarantines='on',
antivax=0,
vaxcost=100,
startermoney=500,
allowance=200,
quarantinecost=300,
beta=0.6,
gamma=0.3,
curechance=0,
icost=50,
dcost=50,
ccost=300,
zcost=400,
betainc=0.02,
gammadec=0.02,
campchance=0.1):
turnNum = 0
money = startermoney
gameOver = False
if ((mode != 'Game' and mode != 'Simulation') or (Gtype != 'erdos')
or (difficulty != 'Baby' and difficulty != 'Custom'
and difficulty != 'Normal' and difficulty != 'Brutal'
and difficulty != 'Mega Brutal' and difficulty != 'Impossible')
or (starttype != 'random' and starttype != 'choice'
and starttype != 'high degree')
or (vaccines != 'on' and vaccines != 'off')
or (quarantines != 'on' and quarantines != 'off')):
raise Exception("Something is wrong with your inputs. ")
if (starters != None):
numstarters = len(starters)
if (difficulty == 'Baby'):
if (ethics == 'Good'):
startermoney = 600
allowance = 300
vaxcost = 100
quarantinecost = 300
beta = 0.5
gamma = 0.5
if (ethics == 'Evil'):
G = nx.erdos_renyi_graph(30, 0.25)
startermoney = 600
allowance = 300
if (difficulty == 'Normal'):
if (ethics == 'Good'):
startermoney = 500
allowance = 250
beta = 0.5
gamma = 0.25
if (ethics == 'Evil'):
G = nx.erdos_renyi_graph(40, 0.15)
startermoney = 500
allowance = 150
if (difficulty == 'Brutal'):
if (ethics == 'Good'):
startermoney = 500
allowance = 150
beta = 0.6
gamma = 0.25
if (ethics == 'Evil'):
G = nx.erdos_renyi_graph(40, 0.05)
startermoney = 500
allowance = 100
if (G == None):
G = nx.erdos_renyi_graph(node_num, erdosval)
if (difficulty == 'Mega Brutal'):
if (ethics == 'Good'):
G = nx.erdos_renyi_graph(70, 0.08)
startermoney = 500
allowance = 100
vaxcost = 100
quarantinecost = 300
beta = 0.75
gamma = 0.1
antivax = 0.2
numstarters = 4
starttype = 'random'
campchance = 0.1
# 4 random starters
if (ethics == 'Evil'):
G = nx.erdos_renyi_graph(70, 0.05)
startermoney = 400
allowance = 100
icost = 50
dcost = 50
ccost = 300
zcost = 400
betainc = 0.02
gammadec = 0.02
numstarters = 3
starttype = 'random'
if (difficulty == 'Impossible'):
if (ethics == 'Good'):
G = nx.erdos_renyi_graph(70, 0.15)
startermoney = 200
allowance = 50
vaxcost = 100
quarantinecost = 300
beta = 1
gamma = 0.1
antivax = 0.4
numstarters = 6
starttype = 'high degree'
campchance = 0.1
if (ethics == 'Evil'):
G = nx.erdos_renyi_graph(70, 0.02)
startermoney = 200
allowance = 50
icost = 50
dcost = 50
ccost = 300
zcost = 400
betainc = 0.02
gammadec = 0.02
numstarters = 1
starttype = 'random'
if (mode == 'Simulation'):
vaccines = 'off'
quarantines = 'off'
ethics = 'Good'
# numstarters
z = np.zeros(G.number_of_nodes())
# Tested all start types. Works.
if (starttype == 'random'):
#initialize z randomly
a = random.sample(range(0, G.number_of_nodes()), numstarters)
for i in a:
z[i] = 1
#print(z)
elif (starttype == 'high degree'):
count = copy.deepcopy(numstarters)
finals = []
eye = []
jay = []
for i in G.nodes():
eye.append(i)
jay.append(G.degree[i])
#print(jay)
while (count != 0):
loc = jay.index(max(jay))
finals.append(loc)
#print(loc[0])
jay[loc] = -1
count -= 1
#print(count)
#print(jay)
for i in finals:
#print(i)
z[i] = 1
#print(z)
#print(jay)
elif (starttype == 'choice'):
for i in starters:
z[i] = 1
#print(z)
def Menu():
if (ethics == 'Good'):
print('Turn number - ' + str(turnNum))
print('Money - ' + str(money))
print('\nCommands: ')
print('N - Visualize netwulf representation')
if (quarantines == 'on'):
print('Q - Quarantine a node')
if (vaccines == 'on'):
print('V - Vaccinate a node')
print('P - Progress to the next turn')
print('H - View the help menu')
print('E - Exit the game')
elif (ethics == 'Evil'):
print('Turn number - ' + str(turnNum))
print('Money - ' + str(money))
print('\nCommands: ')
print('N - Visualize netwulf representation')
print('I - Make your disease more infectious')
print('D - Make your disease less deadly')
print('C - Create an anti-vaxx marketing campaign')
print('Z - Infect a node')
print('P - Progress to the next turn')
print('H - View the help menu')
print('E - Exit the game')
else:
raise Exception("ethics is not correctly specified.")
inp = input()
return (inp)
while (gameOver == False): #start of a turn
#print("are you looping")
turnNum += 1
money += allowance
turnOver = False
while (turnOver == False):
inp = Menu()
if (inp == 'N'):
netwulf.visualize(zToG(G, z))
elif (inp == 'P'):
turnOver = True
elif (inp == 'E'):
raise Exception("You are a quitter.")
elif (inp == 'H'):
print("A few tips:")
print(
"In the netwulf interface, press 'post to python' to exit. Otherwise it might glitch."
)
print(
"Green nodes are susceptible, yellow nodes are infected, and red nodes are dead."
)
print(
"Blue nodes are immune, black nodes are quarantined, and pink nodes are anti-vaxx."
)
print("Quarantined nodes update at the end of each turn.")
print(
"More information can be found on the github page: https://github.com/thekadenh/betternx/"
)
if (ethics == 'Good'):
if (inp == 'Q'):
yn = input(
str("Do you want to quarantine a node for $" +
str(quarantinecost) + "? (y/n)"))
if (yn == 'y'):
if (money >= quarantinecost):
money -= quarantinecost
q = input("Which node do you want to quarantine? ")
q = int(q)
zq = z[q]
if (zq == 2):
print(
str(q) +
" is literally dead. You're quarantining a dead person. Nice one."
)
if (zq == 3):
print(
str(q) +
" can't get the virus. No idea why you're quarantining it but you do you."
)
if (zq == 4):
print(
"I mean... technically you CAN quarantine "
+ str(q) +
" twice... It's not against the rules or anything..."
)
if (zq == 5):
print("Excellent choice")
z[q] = 4
else:
z[q] = 4
else:
print("Sorry, you're too poor")
elif (inp == 'V'):
yn = input(
str("Do you want to vaccinate a node for $" +
str(vaxcost) + "? (y/n)"))
if (yn == 'y'):
if (money >= vaxcost):
money -= vaxcost
q = input("Which node do you want to vaccinate? ")
q = int(q)
zq = z[q]
if (zq == 1):
print(
str(q) +
" is already infected, dummy. Vaccination doesn't do anything at this point."
)
elif (zq == 2):
print(str(q) + "... They're dead.")
elif (zq == 3):
print("You make... questionable... decisions.")
elif (zq == 4):
print("They're quarantined.")
elif (zq == 5):
print(
"They refuse, citing the 100% true nonrefutable fact that vaccinations cause autism."
)
else:
z[q] = 3
else:
print("Sorry, you're too poor")
elif (ethics == 'Evil'):
if (inp == 'I'):
yn = input(
str("Do you want to increase beta by " + str(betainc) +
" for $" + str(icost) + "? (y/n)"))
if (yn == 'y'):
if (money >= icost):
beta = beta + betainc
money -= icost
else:
print("Sorry, you're too poor")
elif (inp == 'D'):
yn = input(
str("Do you want to decrease gamma by " +
str(gammadec) + " for $" + str(dcost) + "? (y/n)"))
if (yn == 'y'):
if (money >= dcost):
gamma = gamma - gammadec
money -= dcost
else:
print("Sorry, you're too poor")
elif (inp == 'C'):
yn = input(
str("Do you want to fund an anti-vax campaign for $" +
str(ccost) + "? (y/n)"))
if (yn == 'y'):
if (money >= ccost):
money -= ccost
for i in G.nodes():
if (z[i] == 0):
if (random.random() < campchance):
z[i] == 5
else:
print("Sorry, you're too poor")
elif (inp == 'Z'):
yn = input(
str("Do you want to infect ANY node for $" +
str(zcost) + "? (y/n)"))
if (yn == 'y'):
if (money >= zcost):
money -= zcost
nod = input(
str("Which node would you like to infect?"))
nod = int(nod)
znod = z[nod]
if (znod == 2):
print(
"You brought back node " + str(nod) +
" from the dead. The zombie apocalypse is imminent!"
)
z[nod] = 1
if (znod == 3):
print(
"You used voodoo magic to anti-vaccinate node "
+ str(nod) + ".")
z[nod] = 1
if (znod == 4):
print("You successfully broke node " +
str(nod) + " out of the quarantine!")
z[nod] = 1
if (znod == 5):
print(
"I mean... node " + str(nod) +
" basically wanted to get infected anyway")
z[nod] = 1
else:
z[nod] = 1
else:
print("Sorry, you're too poor")
# at the end of the turn cycle through the quarantined ones and separate the edges.
# bunch=[(1,2),(2,3)]
# G.remove_edges_from(ebunch)
if (turnOver == True):
for i, j in enumerate(z):
if (j == 4):
for k in G.nodes():
G.remove_edges_from([(i, k)])
#Then, run a cycle of the thingy
z2 = copy.deepcopy(z)
for i, j in enumerate(z):
if (j == 1): # it's infected, time to spread!
for k in G.edges(i):
if (z[k[1]] == 0 or z[k[1]] == 5):
if (random.random() < beta):
z2[k[1]] = 1
if (random.random() < gamma):
z2[i] = 2
z = z2
if not 1 in z:
gameOver = True
#drawGz(G, z)
sus = 0
dead = 0
recovered = 0
qud = 0
antvd = 0
for i in z:
if (i == 0):
sus += 1
if (i == 2):
dead += 1
if (i == 3):
recovered += 1
if (i == 4):
qud += 1
if (i == 5):
antvd += 1
print("Game over! Thanks for playing.")
print(
"I'm not going to tell you how well you did. That's for you to decide."
)
print("However, these stats may offer some insight.\n")
print("# Susceptible: " + str(sus))
print("# Dead: " + str(dead))
print("# Vaccinated or recovered: " + str(recovered))
print("# Quarantined: " + str(qud))
print("# Alive Anti-vaxxers: " + str(antvd))
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)
# if not node_list.__contains__(r[2]):
# node_list.append(r[2])
# print 'type of'
# print(type(test_file))
# print 'edge list'
# print edge_list
# print'#######'
# print(node_list)
n = 4 #len(node_list) # finding total nodes
p = 1
g = nx.read_edgelist(test_file,
delimiter=',',
nodetype=str,
create_using=nx.erdos_renyi_graph(n, p))
attr = {n: {"infected": False} for n in g.nodes()}
nx.set_node_attributes(g, attr)
#g.add_nodes_from(node_list) #NOT NEEDED
nx.draw(g, with_labels=True)
print(g.edges(data=True))
print '##########'
print 'Atrribute for one node'
#print(g.node['A']['infected'])
#print(g.node['P']['infected'])
print '#Atrribute for one node' #'
#plt.draw()
#plt.show()
import networkx as nx
import matplotlib.pyplot as plt
from textwrap import wrap
import json
import random
GRAPH_SIZE = 30
host_num = 1
short_paths = {}
graph = nx.erdos_renyi_graph(GRAPH_SIZE, 0.3)
while not nx.is_connected(graph):
graph = nx.erdos_renyi_graph(GRAPH_SIZE, 0.3)
for s_node in range(GRAPH_SIZE):
short_paths['s' + str(s_node + 1)] = {}
for t_node in range(GRAPH_SIZE):
paths = [path for path in nx.all_shortest_paths(graph, s_node, t_node)]
short_paths['s' + str(s_node + 1)]['s' + str(t_node + 1)] = map(
lambda x: map(lambda y: 's' + str(y + 1), x), paths)
ids = map(lambda x: 's' + str(x + 1), range(GRAPH_SIZE))
dpids = map(lambda x: ':'.join(wrap('%016x' % (x + 1), 2)), range(GRAPH_SIZE))
hosts = []
links = []
switches = map(
lambda x: {
"id": ids[x],
xdata, ydata = [], []
def run(data):
# update the data
t, y = data
xdata.append(t)
ydata.append(y)
xmin, xmax = ax.get_xlim()
if t >= xmax:
ax.set_xlim(xmin, 2*xmax)
ax.figure.canvas.draw()
line.set_data(xdata, ydata)
return line,
ani = animation.FuncAnimation(fig, run, data_gen, blit=False, interval=10,
repeat=False, init_func=init)
plt.show()
"""
Network graph
"""
G = nx.erdos_renyi_graph(50, 0.5)
nx.draw_spring(G, node_color='purple', node_size=200, edge_color='pink', width=2)
plt.figure()
G = nx.complete_graph(10)
nx.draw(G)
plt.savefig("complete10.png")
plt.figure()
G = nx.complete_bipartite_graph(3, 100)
nx.draw(G)
plt.savefig("compbipartite.png")
plt.figure()
G = nx.barbell_graph(10, 10)
nx.draw(G)
plt.savefig("barbell.png")
plt.figure()
G = nx.lollipop_graph(10, 20)
nx.draw(G)
plt.savefig("lollipop.png")
plt.figure()
G = nx.karate_club_graph()
nx.draw(G)
plt.savefig("karate_club.png")
plt.figure()
G = nx.erdos_renyi_graph(500, 0.01)
nx.draw(G)
plt.savefig("erdos_renyi.png")
#plt.show()
"""
Some rudimentary tests. Instantiates a Plot object, but doesn't test plotting.
Discovered that this set of rudimentary tests might be necessary after seeing
the following issue:
https://github.com/ericmjl/nxviz/issues/160
"""
from random import random
import networkx as nx
from nxviz import ArcPlot, CircosPlot, GeoPlot, MatrixPlot
G = nx.erdos_renyi_graph(n=20, p=0.2)
G_geo = G.copy()
for n, d in G_geo.nodes(data=True):
G_geo.node[n]['latitude'] = random()
G_geo.node[n]['longitude'] = random()
G_geo.node[n]['dpcapacity'] = random()
def test_circos_plot():
c = CircosPlot(G) # noqa: F841
def test_matrix_plot():
m = MatrixPlot(G) # noqa: F841
def weights_allocation(A, Y):
A_exp = expanded_adjacency(A)
pinv = np.linalg.pinv(A_exp)
sol = np.dot(pinv, Y)
return sol
complete = networkx.complete_graph(5)
A_complete = networkx.to_numpy_matrix(complete)
A_complete = np.asarray(A_complete)
star = networkx.star_graph(4)
A_star = networkx.to_numpy_matrix(star)
A_star = np.asarray(A_star)
er = networkx.erdos_renyi_graph(5, 0.5)
networkx.draw(er)
A_er = networkx.to_numpy_matrix(er)
A_er = np.asarray(A_er)
cycle = networkx.cycle_graph(5)
A_cycle = networkx.to_numpy_matrix(cycle)
A_cycle = np.asarray(A_cycle)
y = np.zeros((5, 1))
y[0, 0] = 100
y[1, 0] = -100
y[2, 0] = 200
y[3, 0] = -100
y[4, 0] = -100
def __init__(self,
nr_infected=5,
nr_exposed=10,
nr_recovered_immune=0,
simultanousAct=True,
network_type='watts_strogatz_graph',
human_population=200,
ratio_vectors_per_person=.5,
intrinsic_incubation_period=5.5,
extrinsic_incubation_period=7,
m_prob_reproduce=.02,
transmission_prob_human_to_vector=.9,
transmission_prob_vector_to_human=.9,
blood_meals_per_day=4,
share_m_vertical_transmission=.11,
recovery_period_human=5,
sexual_intercourse_day=.2,
share_symptomatic_humans=.2,
share_infected_mosquitos=0,
share_extreme_poverty=.2,
network_connectivity=2.5):
'''
Initialize model parameters
'''
self.Zika_Cases = 0
self.human_population = human_population
self.initial_Mosquitos = int(human_population *
ratio_vectors_per_person)
self.simultanousAct = simultanousAct
self.network_type = network_type
self.extrinsic_incubation_period = extrinsic_incubation_period
self.intrinsic_incubation_period = intrinsic_incubation_period
self.transmission_prob_human_to_vector = transmission_prob_human_to_vector
self.transmission_prob_vector_to_human = transmission_prob_vector_to_human
self.m_prob_reproduce = m_prob_reproduce
self.blood_meals_per_day = blood_meals_per_day
self.share_m_vertical_transmission = share_m_vertical_transmission
self.recovery_period_human = recovery_period_human
self.sexual_intercourse_day = sexual_intercourse_day
self.share_symptomatic_humans = share_symptomatic_humans
self.share_infected_mosquitos = share_infected_mosquitos
number_of_links = int(network_connectivity * human_population)
###################
# Agent Activation#
###################
if self.simultanousAct == False:
self.schedule = ActivationByBreed(self, False)
else:
self.schedule = ActivationByBreed(self, True)
###########
# Network #
###########
# Random Network: binomial_graph
if network_type == 'erdos_renyi_graph':
link_probability = (float(number_of_links) /
float(human_population**2)) * 1.6
self.network = nx.erdos_renyi_graph(human_population,
link_probability)
#Scale-free network (Powerlaw)
elif network_type == 'barabasi_albert_graph':
self.network = nx.barabasi_albert_graph(
human_population, number_of_links / human_population)
# Network: small-world graph
elif network_type == 'watts_strogatz_graph':
link_probability = (float(number_of_links) /
float(human_population**2)) * 1.6
self.network = nx.watts_strogatz_graph(human_population,
family_size,
link_probability)
# cellular automaton
elif network_type == 'grid_2d_graph':
self.network = nx.grid_2d_graph(
int(round(np.sqrt(human_population))),
int(round(np.sqrt(human_population))),
periodic=True)
self.network = nx.convert_node_labels_to_integers(self.network)
self.human_population = int(round(np.sqrt(human_population)))**2
else:
raise Exception(
"Not recognized Network, please select a different network type"
)
self.datacollector = DataCollector(
model_reporters={
"m_susceptible":
lambda m: self.count_type(m, "susceptible", Mosquito),
"m_exposed":
lambda m: self.count_type(m, "exposed", Mosquito),
"m_infectious":
lambda m: self.count_type(m, "infectious", Mosquito),
"h_susceptible_rich":
lambda m: self.count_type(m, "susceptible", Human) - self.
count_poor_human(m, "susceptible"),
"h_exposed_rich":
lambda m: self.count_type(
m, "exposed", Human) - self.count_poor_human(m, "exposed"),
"h_symptomatic_infectious_rich":
lambda m: self.count_type(m, "infectious", Human, True) - self.
count_poor_human(m, "infectious", True),
"h_asymptomatic_infectious_rich":
lambda m: self.count_type(m, "infectious", Human) - self.
count_poor_human(m, "infectious"),
"h_recovered_immune_rich":
lambda m: self.count_type(m, "recovered_immune", Human) - self.
count_poor_human(m, "recovered_immune"),
"h_susceptible_poor":
lambda m: self.count_poor_human(m, "susceptible"),
"h_exposed_poor":
lambda m: self.count_poor_human(m, "exposed"),
"h_symptomatic_infectious_poor":
lambda m: self.count_poor_human(m, "infectious", True),
"h_asymptomatic_infectious_poor":
lambda m: self.count_poor_human(m, "infectious"),
"h_recovered_immune_poor":
lambda m: self.count_poor_human(m, "recovered_immune"),
"cumulative_cases":
lambda m: m.Zika_Cases,
})
# Create Mosquitos:
for i in range(self.initial_Mosquitos):
node_ID = random.choice(self.network.nodes())
if self.share_infected_mosquitos >= random.uniform(0., 1.0):
M_condition = 'infected'
else:
M_condition = 'susceptible'
new_mosquito = Mosquito(
node_ID=node_ID,
condition=
M_condition, # Assumes all mosquitoes are susceptible initially
age=int(np.random.uniform(0, average_M_lifespan)),
# age = int(np.random.triangular(0, average_M_lifespan/2.0, average_M_lifespan)),
)
self.schedule.add(new_mosquito)
# print ('infected', nr_infected)
# print ('nr_exposed', nr_exposed)
# print ('nr_recovered_immune', nr_recovered_immune)
# Create Humans
for i in range(self.human_population):
node_ID = random.choice(self.network.nodes())
if nr_infected > 0:
condition = "infectious"
nr_infected -= 1
elif nr_recovered_immune > 0:
condition = "recovered_immune"
nr_recovered_immune -= 1
elif nr_exposed > 0:
condition = "exposed"
nr_exposed -= 1
else:
condition = "susceptible"
if share_extreme_poverty >= random.uniform(0., 1.0):
income_group = 'poor'
else:
income_group = 'rich'
new_person = Human(self, node_ID, condition, income_group)
self.schedule.add(new_person)
# Auto run until stop
self.running = False
import networkx as nx
n = int(input("Enter #vertices: "))
p = float(input("Enter Edge probability: "))
er = nx.erdos_renyi_graph(n, p)
f_name = raw_input("Enter file name: ")
f = open(f_name, "w")
for x in er.edges():
f.write(str(x[0]) + ' ' + str(x[1]))
f.write('\n')
print str(er.number_of_nodes()) + ' ' + str(er.number_of_edges())
WRITE("Networkx version:" + str(nx.__version__))
init_cond = {
'N': N,
'f': f,
'mean_degree': mean_degree,
'K': K,
'steps': steps
}
WRITE("N=" + str(N) + "\nf=" + str(f) + "\nmean_degree=" + str(mean_degree) +
"\nK=" + str(K) + "\nsteps=" + str(steps))
#np.random.seed(1)
G_undir = nx.erdos_renyi_graph(N, mean_degree / N)
G_dir = nx.DiGraph()
G_dir.add_nodes_from(range(N))
G_dir.add_edges_from(G_undir.edges())
A = nx.to_numpy_matrix(G_dir.to_undirected(), dtype=np.int)
#fig = plt.figure(figsize=(5, 5))
#plt.title("Adjacency Matrix")
#plt.imshow(A,cmap="Greys",interpolation="none")
#%matplotlib inline
#sns.heatmap(A, cmap="Greys")
#plt.show()
#storex = np.zeros((N,steps))
def generate_erdos_renyi_netx(p, N):
""" Generate random Erdos Renyi graph """
g = networkx.erdos_renyi_graph(N, p)
W = networkx.adjacency_matrix(g).todense()
return torch.as_tensor(W, dtype=torch.float)
__author__ = 'Bhavin.Parekh'
import networkx as nx
import random
import ndlib.models.ModelConfig as mc
import ndlib.models.CompositeModel as gc
import ndlib.models.compartments.NodeCategoricalAttribute as ns
# Network generation
g = nx.erdos_renyi_graph(1000, 0.1)
# Setting node attribute
attr = {n: {"Sex": random.choice(['male', 'female'])} for n in g.nodes()}
nx.set_node_attributes(g, attr)
# Composite Model instantiation
model = gc.CompositeModel(g)
# Model statuses
model.add_status("Susceptible")
model.add_status("Infected")
model.add_status("Removed")
# Compartment definition
c1 = na.NodeCategoricalAttribute("Sex", "male", probability=0.6)
# Rule definition
model.add_rule("Susceptible", "Infected", c1)
# Model initial status configuration
config = mc.Configuration()
# Created by Filip Slazyk
# MOwNiT 2
# 2018/2019
import networkx as nx
import csv
import numpy as np
# Random graph n=30 r = 1
G = nx.erdos_renyi_graph(30, 0.2)
edges = G.edges()
with open('./graphs_csv/random_graph.csv', 'w') as writeFile:
writer = csv.writer(writeFile)
for edge in edges:
writer.writerow(edge + (1, ))
writeFile.close()
# 3-regular graph n=50 r = 1
G = nx.random_regular_graph(3, 50)
edges = G.edges()
with open('./graphs_csv/3_regular_graph.csv', 'w') as writeFile:
writer = csv.writer(writeFile)
for edge in edges:
writer.writerow(edge + (1, ))
writeFile.close()
# Graph with bridge n=40 r in (0,10)
G = nx.erdos_renyi_graph(20, 0.2)
edges = G.edges()
with open('./graphs_csv/graph_with_bridge.csv', 'w') as writeFile:
writer = csv.writer(writeFile)
def test_community():
G = nx.erdos_renyi_graph(20, 0.1)
prediction = Community(G).predict()
assert_less_equal(len(prediction), 190)
