def execute_model(G, number_of_iterations, number_of_executions):
"""
Execute the TD model
:return: df including model results)
"""
nodes = []
for node in G.nodes:
nodes.append(node)
df_mod_multi = pd.DataFrame(0, index=list(range(0, number_of_iterations)), columns=nodes)
for infected_node in nodes:
# print(infected_node)
model = TDMethod(G)
cfg_mod = mc.Configuration()
cfg_mod.add_model_parameter('beta', 'individual betas') # infection rate
infection_sets = []
infection_sets.append(infected_node)
cfg_mod.add_model_initial_configuration("Infected", infection_sets)
model.set_initial_status(cfg_mod)
trends_multi = multi_runs(model, execution_number=number_of_executions,
iteration_number=number_of_iterations, nprocesses=10)
execution_list = list(range(0, number_of_executions))
for ex_n in execution_list:
list_of_infected_nodes = trends_multi[ex_n]['trends']['node_count'][1]
iterator_ifn = 0
for ifn in list_of_infected_nodes:
df_mod_multi.at[iterator_ifn, infected_node] = df_mod_multi.at[iterator_ifn, infected_node] + ifn
iterator_ifn = iterator_ifn + 1
df_mod_multi = df_mod_multi / number_of_executions
return df_mod_multi
def full_simulate_net_diffusion(frac_infected=0.01,
threshold=0.038,
profile=0.0000105,
p_removal=0.22,
num_exec=20,
num_iter=32,
nproc=8):
# Network generation
g = nx.erdos_renyi_graph(1000, 0.1)
# Composite Model instantiation
sir_th_model = CompMod.CompositeModel(g)
# Model statuses
sir_th_model.add_status("Susceptible")
sir_th_model.add_status("Infected")
sir_th_model.add_status("Removed")
# Compartment definition
c1 = NodeThreshold(threshold=None, triggering_status="Infected")
c2 = NodeStochastic(p_removal)
# Rule definition
sir_th_model.add_rule("Susceptible", "Infected", c1)
sir_th_model.add_rule("Infected", "Removed", c2)
# Model initial status configuration, assume 1% of population is infected
config = MoCon.Configuration()
config.add_model_parameter('fraction_infected', frac_infected)
# Setting nodes parameters
for i in g.nodes():
config.add_node_configuration("threshold", i, threshold)
config.add_node_configuration("profile", i, profile)
# Simulation execution
sir_th_model.set_initial_status(config)
trends = multi_runs(sir_th_model,
execution_number=num_exec,
iteration_number=num_iter,
nprocesses=nproc)
# Convert into a dataframe that lists each number of infected nodes by iteration number (to make average
# calculation)
df_infected = pd.DataFrame(
[execution['trends']['node_count'][1] for execution in trends])
# Normalize each run, so that they are consistent with Google Trends Data for comparison:
df_infected = df_infected.apply(lambda x: x / x.max(), axis=1)
df_infected = pd.melt(df_infected,
var_name='Execution',
value_name='Infected')
df_infected['Infected'] *= 100
return df_infected
def simulate_net_diffusion(frac_infected=0.01,
threshold=0.18,
profile=0.00001,
p_removal=0.017,
num_exec=10,
num_iter=100,
nproc=8):
g = nx.erdos_renyi_graph(1000, 0.1)
# Composite Model instantiation
sir_th_model = CompMod.CompositeModel(g)
# Model statuses
sir_th_model.add_status("Susceptible")
sir_th_model.add_status("Infected")
sir_th_model.add_status("Removed")
# Compartment definition
c1 = NodeThreshold(threshold=None, triggering_status="Infected")
c2 = NodeStochastic(p_removal)
# Rule definition
sir_th_model.add_rule("Susceptible", "Infected", c1)
sir_th_model.add_rule("Infected", "Removed", c2)
# Model initial status configuration
config = MoCon.Configuration()
config.add_model_parameter('fraction_infected', frac_infected)
# Setting nodes parameters
for i in g.nodes():
config.add_node_configuration("threshold", i, threshold)
config.add_node_configuration("profile", i, profile)
# Simulation execution
sir_th_model.set_initial_status(config)
trends = multi_runs(sir_th_model,
execution_number=num_exec,
iteration_number=num_iter,
nprocesses=nproc)
df_infected = pd.DataFrame(
[execution['trends']['node_count'][1] for execution in trends])
# Normalize each run:
df_infected = df_infected.apply(lambda x: x / x.max(), axis=1)
df_infected = pd.melt(df_infected,
var_name='Execution',
value_name='Infected')
# Normalize (mean) values so that they are consistent with Google Trends Data for comparison:
y_forecasted = df_infected.groupby('Execution').mean() * 100
return y_forecasted
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 test_multiple_si_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.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):
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_multi_initial_set(self):
# Network topology
g = nx.erdos_renyi_graph(1000, 0.1)
# Model selection
model1 = epd.SIRModel(g)
# Model Configuration
config = mc.Configuration()
config.add_model_parameter('beta', 0.001)
config.add_model_parameter('gamma', 0.01)
model1.set_initial_status(config)
# Simulation multiple execution
infection_sets = [(1, 2, 3, 4, 5), (3, 23, 22, 54, 2), (98, 2, 12, 26, 3), (4, 6, 9)]
trends = multi_runs(model1, execution_number=4, iteration_number=100, infection_sets=infection_sets,
nprocesses=4)
self.assertIsNotNone(trends)
def test_multi(self):
# Network topology
g = nx.erdos_renyi_graph(1000, 0.1)
# Model selection
model1 = epd.SIRModel(g)
# Model Configuration
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)
model1.set_initial_status(config)
# Simulation multiple execution
trends = multi_runs(model1, execution_number=10, iteration_number=100, infection_sets=None, nprocesses=4)
self.assertIsNotNone(trends)
def simulate_spread(G, steps, threshold, infected_probability, simulation_beta,
simulation_gamma, simulation_alpha, output):
infected_nodes = []
exposed_nodes = [
node[0] for node in G.nodes(data=True) if node[1]['flaws'] > threshold
]
# Take 1 at random and the rest with probability
idx = np.random.choice(list(range(len(exposed_nodes))),
size=1,
replace=False)[0]
infected_nodes.append(exposed_nodes.pop(idx))
infected_nodes_count = int(len(exposed_nodes) * infected_probability)
if infected_nodes_count != 0:
infected_idxs = np.random.choice(list(range(len(exposed_nodes))),
infected_nodes_count)
infected_nodes.extend(list(np.take(exposed_nodes, infected_idxs)))
exposed_nodes = list(np.delete(exposed_nodes, infected_idxs))
susceptible_nodes = [
node for node_idx, node in enumerate(G.nodes())
if node_idx not in [*exposed_nodes, *infected_nodes]
]
# Create model
model = ep.SEIRModel(G)
# Create configuration
cfg = mc.Configuration()
# Infection probability.
cfg.add_model_parameter('beta', simulation_beta)
# Infected -> Remove probability
cfg.add_model_parameter('gamma', simulation_gamma)
# Latent period
cfg.add_model_parameter('alpha', simulation_alpha)
# Set both infected and exposed nodes.
# cfg.add_model_parameter('fraction_infected', 0.01)
cfg.add_model_initial_configuration("Susceptible", susceptible_nodes)
cfg.add_model_initial_configuration("Exposed", exposed_nodes)
cfg.add_model_initial_configuration("Infected", infected_nodes)
# Set the configuration
model.set_initial_status(cfg)
# Run multiple models
trends = multi_runs(model,
execution_number=10,
iteration_number=steps,
infection_sets=None,
nprocesses=5)
dt = DiffusionTrend(model, trends)
dt.plot(filename=os.path.join(output, 'diffusion_trend.png'))
dp = DiffusionPrevalence(model, trends)
dp.plot(filename=os.path.join(output, 'diffusion_prevalence.png'))
# Other run to show
infected_nodes = list()
for _ in range(10):
model.reset()
iterations = model.iteration_bunch(steps)
for iteration in iterations:
for k, v in iteration['status'].items():
if v == 3:
infected_nodes.append(k)
return Counter(infected_nodes)
# Rule Definition
model.add_rule("Susceptible","Exposed",c1_1)
model.add_rule("Susceptible","Exposed",c1_3)
model.add_rule("Exposed","Symptomatic",c2_1)
model.add_rule("Symptomatic","Removed",c3)
model.add_rule("Infected","Removed",c4)
# Model Configuration
config = mc.Configuration()
config.add_model_parameter('fraction_infected', initialinfect/N)
model.set_initial_status(config)
# Simulation
print('-----Doing {} simulation(s) on {} day test-----'.format(executions,itercount))
trends = multi_runs(model, execution_number = executions, iteration_number = iterations, infection_sets=None)
stop_time = time.time()
total_time = stop_time - start_time
print('\n----- Total Time: {} seconds ----'.format(total_time))
print('-----Plotting Results-----')
#print(iterations)
#print(trends)
from ndlib.viz.mpl.DiffusionTrend import DiffusionTrend
daydata = []
fig = ()
ax = ()
for n in range(0, executions):
if (trends[n]['trends']['node_count'][0][-1] != (N - initialinfect)):
