def get_seir_params():
print('\n\tInput SEIR model parameters')
beta = float(input('beta(infection probability)[0, 1]: '))
gamma = float(input('gamma(removal probability)[0, 1]: '))
alpha = float(input('alpha(latent period)[0, 1]: '))
fraction_infected = float(input('fraction_infected(initial)[0, 1]: '))
cfg = mc.Configuration()
cfg.add_model_parameter('beta', beta) # 0.01
cfg.add_model_parameter('gamma', gamma) # 0.005
cfg.add_model_parameter('alpha', alpha) # 0.05
cfg.add_model_parameter("fraction_infected", fraction_infected) # 0.05
return cfg
def get_seis_params():
print('\n\tInput SEIS model parameters')
beta = float(input('beta(infection probability)[0, 1]: '))
lambda_param = float(input('lambda(recovery probability)[0, 1]: '))
alpha = float(input('alpha(latent period)[0, 1]: '))
fraction_infected = float(input('fraction_infected(initial)[0, 1]: '))
cfg = mc.Configuration()
cfg.add_model_parameter('beta', beta) # 0.01
cfg.add_model_parameter('lambda', lambda_param) # 0.005
cfg.add_model_parameter('alpha', alpha) # 0.05
cfg.add_model_parameter("fraction_infected", fraction_infected) # 0.05
return cfg
def create_model(self,model_type,network):
if self.config["UI"].getboolean("verbose"):
print("Qu: Creating model ... ")
# Model Selection
if model_type == 'SIR':
self._active_model = SICR_model.generate_model(self._active_network)
else:
self._active_model = 0
# Model Configuration
config = mc.Configuration()
config.add_model_parameter("fraction_infected", 0.01)
self._active_model.set_initial_status(config)
return self._active_model
def test_threshold_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = th.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
threshold = 0.2
for i in g.nodes():
config.add_node_configuration("threshold", i, threshold)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def test_node_threshold(self):
# Fixed Threshold
g = nx.erdos_renyi_graph(1000, 0.1)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c1 = cpm.NodeThreshold(0.1, triggering_status="Infected")
model.add_rule("Susceptible", "Infected", c1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
# Ad-hoc Threshold
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c1 = cpm.NodeThreshold(triggering_status="Infected")
model.add_rule("Susceptible", "Infected", c1)
config = mc.Configuration()
for i in g.nodes():
config.add_node_configuration("threshold", i,
np.random.random_sample())
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def test_seis_model(self):
for g in get_graph(True):
model = epd.SEISModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('lambda', 0.2)
config.add_model_parameter('alpha', 0.05)
config.add_model_parameter("fraction_infected", 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
for g in get_directed_graph(True):
model = epd.SEISModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('lambda', 0.8)
config.add_model_parameter('alpha', 0.5)
config.add_model_parameter("fraction_infected", 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def test_profile_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = pr.ProfileModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
profile = 0.1
for i in g.nodes():
config.add_node_configuration("profile", i, profile)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def test_multiple_si_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = si.SIModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.01)
config.add_model_parameter("percentage_infected", 0.1)
model.set_initial_status(config)
executions = ut.multi_runs(model,
execution_number=10,
iteration_number=50)
self.assertEqual(len(executions), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def test_multiple_si_model(self):
for g in get_graph(True):
model = epd.SIModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.01)
config.add_model_parameter("fraction_infected", 0.1)
model.set_initial_status(config)
executions = ut.multi_runs(model,
execution_number=10,
iteration_number=50)
self.assertEqual(len(executions), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def simulate_si_on_erdos_renyi():
print('######################################')
print('Simulating SI Model on Erdős-Rényi Graph...')
print('######################################')
g = nx.erdos_renyi_graph(1000, 0.15)
model = si.SIModel(g)
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.01)
cfg.add_model_parameter("percentage_infected", 0.05)
model.set_initial_status(cfg)
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
draw_epidemic_plot(model, trends)
def simulate_si_on_barabasi_albert():
print('######################################')
print('Simulating SI Model on Barabasi-Albert Graph...')
print('######################################')
g = nx.barabasi_albert_graph(1000, 10)
model = si.SIModel(g)
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.01)
cfg.add_model_parameter("percentage_infected", 0.05)
model.set_initial_status(cfg)
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
draw_epidemic_plot(model, trends)
def test_initial_infected(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = sis.SISModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('lambda', 0.2)
predefined_infected = [0, 1, 2, 3, 4, 5]
config.add_model_initial_configuration("Infected", predefined_infected)
model.set_initial_status(config)
inft = [k for k, v in future.utils.iteritems(model.status) if v == 1]
self.assertAlmostEqual(inft, predefined_infected)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def test_visualize_prevalence(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = sir.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)
p = viz.plot()
self.assertIsInstance(p, Figure)
def test_seis_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = seis.SEISModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('lambda', 0.2)
config.add_model_parameter('alpha', 0.05)
config.add_model_parameter("percentage_infected", 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
g = g.to_directed()
model = seis.SEISModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('lambda', 0.8)
config.add_model_parameter('alpha', 0.5)
config.add_model_parameter("percentage_infected", 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def get_epidemic_si(graph, beta, perc_inf, infected_nodes):
model_si = si.SIModel(graph)
cfg_si = mc.Configuration()
cfg_si.add_model_parameter("beta", beta)
cfg_si.add_model_parameter("percentage_infected", perc_inf)
cfg_si.add_model_parameter("Infected", infected_nodes)
model_si.set_initial_status(cfg_si)
iteration_si = model_si.iteration_bunch(50)
trends_si = model_si.build_trends(iteration_si)
viz_si = DiffusionTrend(model_si, trends_si)
viz_si.plot()
def sis_model(net, graph_name):
print '\nSIS MODEL SIMULATION - ' + graph_name + ' network'
for_comparison = dict()
degrees = [d for n, d in net.degree]
mean_k = sum(degrees)/len(degrees)
for state in ['ENDEMIC', 'FREE']:
print 'MODEL CONFIGURATION - ' + state + ' STATE'
if state == 'ENDEMIC':
beta = float(raw_input('INFECTION PROBABILITY: '))
print 'MU HAS TO BE LESS THAN ' + str(beta*(mean_k+1))
mu = float(raw_input('RECOVERY PROBABILITY: '))
while mu >= (beta*(mean_k+1)):
print 'ERROR! MU HAS TO BE LESS THAN ' + str(beta*(mean_k+1))
mu = float(raw_input('RECOVERY PROBABILITY: '))
else:
print 'MU HAS TO BE GREATER THAN ' + str(beta*(mean_k+1))
mu = float(raw_input('RECOVERY PROBABILITY: '))
while mu <= beta*(mean_k+1):
print 'ERROR! MU IS NOT GREATER THAN ' + str(beta*(mean_k+1))
mu = float(raw_input('RECOVERY PROBABILITY: '))
cfg = mc.Configuration()
cfg.add_model_parameter('beta', beta)
cfg.add_model_parameter('lambda', mu)
cfg.add_model_parameter('percentage_infected',
float(raw_input('PERCENTAGE INFECTED: ')))
model_sis = sis.SISModel(net)
model_sis.set_initial_status(cfg)
model_sis.name = str(graph_name)+"-"+state.lower()
print model_sis.name
iterations = model_sis.iteration_bunch(200)
trends_sis = model_sis.build_trends(iterations)
viz = DiffusionTrend(model_sis, trends_sis)
viz.plot('../../report/images/spreading/sis/diffusion_' +
graph_name + '_' + state.lower() + '.pdf')
for_comparison[state.lower() + '_state'] = [model_sis, trends_sis]
viz = DiffusionTrendComparison([for_comparison['endemic_state'][0],
for_comparison['free_state'][0]],
[for_comparison['endemic_state'][1],
for_comparison['free_state'][1]])
viz.plot('../../report/images/spreading/sis/diffusion_' + graph_name +
'_comparison.pdf')
def test_algorithmic_bias_model(self):
for g in get_graph():
model = opn.AlgorithmicBiasModel(g, seed=0)
config = mc.Configuration()
config.add_model_parameter("epsilon", 0.32)
config.add_model_parameter("gamma", 1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
_ = model.steady_state(max_iterations=100)
def siModel(filename):
# Network topology
g = nx.read_edgelist(filename, nodetype=int, data=(('weight',float),), create_using=nx.Graph())
# Model selection
model = si.SIModel(g)
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.34)
cfg.add_model_parameter("percentage_infected", 0)
model.set_initial_status(cfg)
col=[]
sus=[]
inf=[]
# Simulation execution
iterations = model.iteration_bunch(4)
for i in iterations:
iter_ind=i['iteration']
#c=i['node_count']
node_status_list=i['status']
#print("Iteration:",iter_ind)
#print(node_status_list)
listOfKeys = [key for (key, value) in node_status_list.items() if value == 1]
#print(listOfKeys)
if(listOfKeys != []):
inf.extend(listOfKeys)
#print("infected nodes = ", inf)
print("total nodes", len(g))
print("infected nodes", len(inf))
if(len(inf) > 5000):
sys.exit()
h = g.subgraph(inf)
#print(len(h))
edgesOfInfectedGraph = list(h.edges())
f = open('DiffusionModel/InfectedGraph.txt', 'w')
f.write(str(inf[0]) + '\n')
for t in edgesOfInfectedGraph:
line = ' '.join(str(x) for x in t)
#print(line)
f.write(line + '\n')
f.close()
#nx.draw_spring(h, cmap = plt.get_cmap('jet'), node_size=100, with_labels= True)
#plt.show()
return inf[0], h
def simulate_cascade(graph_path, threshold):
g = nx.read_weighted_edgelist(graph_path, delimiter=";")
model = ep.ThresholdModel(g)
config = mc.Configuration()
seed_nodes = find_seeds(g)
config.add_model_initial_configuration(
"Infected", seed_nodes) # only seed nodes start as infected
for i in g.nodes():
config.add_node_configuration(
'threshold', i,
threshold) # set threshold to be the same for all nodes
model.set_initial_status(config)
iterations = model.iteration_bunch(50) # execute 50 iterations
return iterations
def get_epidemic_sir(graph, beta, gamma, perc_inf, infected_nodes):
model_sir = sir.SIRModel(graph)
cfg_sir = mc.Configuration()
cfg_sir.add_model_parameter("beta", beta) # infection
cfg_sir.add_model_parameter("gamma", gamma) # recovery
cfg_sir.add_model_parameter("percentage_infected", perc_inf)
cfg_sir.add_model_parameter("Infected", infected_nodes)
model_sir.set_initial_status(cfg_sir)
iterations_sir = model_sir.iteration_bunch(100, node_status=True)
trends_sir = model_sir.build_trends(iterations_sir)
viz_sir = DiffusionTrend(model_sir, trends_sir)
viz_sir.plot()
def get_epidemic_sis(graph, beta, lamb, perc_inf, infected_nodes):
model_sis = sis.SISModel(graph)
cfg_sis = mc.Configuration()
cfg_sis.add_model_parameter("beta", beta)
cfg_sis.add_model_parameter("lambda", lamb)
cfg_sis.add_model_parameter("percentage_infected", perc_inf)
cfg_sis.add_model_parameter("Infected", infected_nodes)
model_sis.set_initial_status(cfg_sis)
iteration_sis = model_sis.iteration_bunch(100)
trends_sis = model_sis.build_trends(iteration_sis)
viz_sis = DiffusionTrend(model_sis, trends_sis)
viz_sis.plot()
def test_independent_cascade_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = ids.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
threshold = 0.1
for e in g.edges():
config.add_edge_configuration("threshold", e, threshold)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def test_visualization(self):
initial_status = {
'status': 0,
}
def update(node, graph, status, attributes, constants):
return -2
# Network definition
g = nx.erdos_renyi_graph(n=100, p=0.5)
output_path = './test.gif'
# Visualization config
visualization_config = {
'plot_interval': 1,
'plot_variable': 'status',
'show_plot': False,
'plot_title': 'Example model',
'animation_interval': 200,
'plot_output': output_path
}
# Model definition
model = gc.ContinuousModel(g, clean_status=True)
model.add_status('status')
# Compartments
condition = cpm.NodeStochastic(1)
# Rules
model.add_rule('status', update, condition)
# Configuration
config = mc.Configuration()
model.set_initial_status(initial_status, config)
model.configure_visualization(visualization_config)
# Simulation
iterations = model.iteration_bunch(2, node_status=True)
trends = model.build_trends(iterations)
model.plot(trends, len(iterations), delta=True, delta_mean=True)
### Plots / data manipulation
model.visualize(iterations)
self.assertTrue(os.path.isfile(output_path))
os.remove(output_path)
def test_bare_model(self):
def initial_addiction(node, graph, status, constants):
addiction = 0
return addiction
def initial_self_confidence(node, graph, status, constants):
self_confidence = 1
return self_confidence
initial_status = {
'addiction': initial_addiction,
'self_confidence': initial_self_confidence
}
def craving_model(node, graph, status, attributes, constants):
current_val = status[node]['addiction']
return min(current_val + 0.1, 1)
def self_confidence_impact(node, graph, status, attributes, constants):
return max(status[node]['self_confidence'] - 0.25, 0)
# Network definition
g = nx.erdos_renyi_graph(n=1000, p=0.1)
# Model definition
addiction_model = gc.ContinuousModel(g)
addiction_model.add_status('addiction')
addiction_model.add_status('self_confidence')
# Compartments
condition = cpm.NodeNumericalVariable('addiction',
var_type=NumericalType.STATUS,
value=1,
op='<')
# Rules
addiction_model.add_rule('addiction', craving_model, condition)
addiction_model.add_rule('self_confidence', self_confidence_impact,
condition)
# Configuration
config = mc.Configuration()
addiction_model.set_initial_status(initial_status, config)
# Simulation
iterations = addiction_model.iteration_bunch(50,
node_status=True,
progress_bar=False)
self.assertEqual(len(iterations), 50)
def test_visualize(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = sir.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)
# Visualization
viz = DiffusionTrend(model, trends)
viz.plot("diffusion.pdf")
os.remove("diffusion.pdf")
def test_kertesz_model(self):
g = nx.complete_graph(100)
model = ks.KerteszThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('adopter_rate', 0.4)
config.add_model_parameter('percentage_blocked', 0.1)
config.add_model_parameter('percentage_infected', 0.1)
threshold = 0.2
for i in g.nodes():
config.add_node_configuration("threshold", i, threshold)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def test_phaseplane(self):
g = nx.barabasi_albert_graph(1000, 3)
model = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.05)
config.add_model_parameter('gamma', 0.09)
config.add_model_parameter("percentage_infected", 0.02)
model.set_initial_status(config)
iterations = model.iteration_bunch(1000)
trends = model.build_trends(iterations)
# Visualization
viz = PhasePlane(model, trends, x="Susceptible", y="Infected")
viz.plot("diffusion.pdf")
os.remove("diffusion.pdf")
def test_edge_num_attribute(self):
g = nx.karate_club_graph()
attr = {(u, v): {"even": int((u + v) % 10)} for (u, v) in g.edges()}
nx.set_edge_attributes(g, attr)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c = cpm.EdgeNumericalAttribute("even", value=0, op="==", probability=1)
model.add_rule("Susceptible", "Infected", c)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c = cpm.EdgeNumericalAttribute("even",
value=[3, 10],
op="IN",
probability=1)
model.add_rule("Susceptible", "Infected", c)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def get_epidemic_threshold(graph, perc_inf, threshold, infected_nodes):
model_threshold = thresh.ThresholdModel(graph)
cfg_threshold = mc.Configuration()
cfg_threshold.add_model_parameter("percentage_infected", perc_inf)
cfg_threshold.add_model_parameter("Infected", infected_nodes)
for node in graph.nodes():
cfg_threshold.add_node_configuration("threshold", node, threshold)
model_threshold.set_initial_status(cfg_threshold)
iteration_threshold = model_threshold.iteration_bunch(25)
trends_threshold = model_threshold.build_trends(iteration_threshold)
viz_threshold = DiffusionTrend(model_threshold, trends_threshold)
viz_threshold.plot()
def simulate_SIS(G, timesteps, beta, lambda_, initial_nodes): ##GVA index
model = sis(G)
cfg = mc.Configuration()
infected_nodes = initial_nodes
cfg.add_model_initial_configuration("Infected", infected_nodes)
cfg.add_model_parameter('beta', beta)
cfg.add_model_parameter('lambda', lambda_)
model.set_initial_status(cfg)
iterations = model.iteration_bunch(timesteps)
trends = model.build_trends(iterations)
return trends, iterations, model