def SEIR_network(G, N, perc_inf, beta, tau_i, tau_r, days, t):
# Alternativa a graph_tools(G) per il solo degree
k = G.degree()
G.degree_list = [d for n, d in k]
G.k_avg = np.mean(G.degree_list)
# EPIDEMIC MODEL
frac_inf = perc_inf / 100
gamma = 1 / tau_i
mu = 1 / tau_r
# Config:
model = ep.SEIRModel(G)
# print(model.parameters)
# print(model.available_statuses)
config = mc.Configuration()
config.add_model_parameter('alpha', gamma)
config.add_model_parameter('beta', beta)
config.add_model_parameter('gamma', mu)
config.add_model_parameter("percentage_infected", frac_inf)
model.set_initial_status(config)
# Run:
iterations = model.iteration_bunch(days, node_status=True)
# trends = model.build_trends(iterations)
# Recover status variables:
s = np.array([
S for S, E, I, R in
[list(it['node_count'].values()) for it in iterations]
]) / N
e = np.array([
E for S, E, I, R in
[list(it['node_count'].values()) for it in iterations]
]) / N
i = np.array([
I for S, E, I, R in
[list(it['node_count'].values()) for it in iterations]
]) / N
r = np.array([
R for S, E, I, R in
[list(it['node_count'].values()) for it in iterations]
]) / N
# resampling through t (variable spacing decided by the ODE solver)
s = np.interp(t, np.arange(0, len(s)), s)
e = np.interp(t, np.arange(0, len(e)), e)
i = np.interp(t, np.arange(0, len(i)), i)
r = np.interp(t, np.arange(0, len(r)), r)
# Plot:
# viz = DiffusionTrend(model, trends)
# viz.plot()
return s, e, i, r
def setup_network(alpha,
beta,
gamma,
infected,
directory=None,
name=None,
size=None,
edge_p=None,
knn=None,
rewire_p=None,
drop=None,
m=None,
n_edges=None,
triangle_p=None):
# Network topology
# Create Graph
if edge_p != None:
print("Making ER Graph")
g = nx.erdos_renyi_graph(size, edge_p)
elif knn != None:
print("Making NWS Graph with drops")
g = nx.newman_watts_strogatz_graph(size, knn, rewire_p)
# drop random edges
for i in range(drop):
e = random.choice(list(g.edges))
g.remove_edge(e[0], e[1])
elif m != None:
print("Making BA Graph")
g = nx.barabasi_albert_graph(size, m)
elif triangle_p != None:
print("Making Powerlaw Cluster Graph")
g = nx.powerlaw_cluster_graph(n=size, m=n_edges, p=triangle_p)
else:
print("Loading custom Graph")
g = nx.read_adjlist(os.path.join(directory, name),
delimiter='\t',
nodetype=int)
# Model selection
m = ep.SEIRModel(g)
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', beta)
cfg.add_model_parameter('gamma', gamma)
cfg.add_model_parameter('alpha', alpha)
cfg.add_model_parameter("fraction_infected", infected)
m.set_initial_status(cfg)
return m
def test_seir_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.SEIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 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)
g = g.to_directed()
model = epd.SEIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 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_seir_model(self):
for g in get_graph(True):
model = epd.SEIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 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.SEIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 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)
import ndlib.models.ModelConfig as mc
import ndlib.models.epidemics as ep
import matplotlib.pyplot as plt
import pandas as pd
# initial conditions and params.
S0 = 20_000_000
I0 = 250
E0 = 0
R0 = 1
# Network topology
g = nx.erdos_renyi_graph(S0, 0.1)
# Model selection
model = ep.SEIRModel(g)
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.01)
cfg.add_model_parameter('gamma', 0.005)
cfg.add_model_parameter('alpha', 0.05)
cfg.add_model_parameter('fraction_infected', 0.05)
model.set_initial_status(cfg)
# Simulation execution
iterations = model.iteration_bunch(200)
df = (pd.DataFrame([i['node_count'] for i in iterations]).rename(columns={
0: 'Susceptible',
1: 'Infected',
2: 'Exposed',
lock.sm = pd.Series(data=None, dtype='float64')
lock.em = pd.Series(data=None, dtype='float64')
lock.im = pd.Series(data=None, dtype='float64')
lock.rm = pd.Series(data=None, dtype='float64')
lock.pm = pd.Series(data=None, dtype='float64')
lock.parsFitm0 = pd.Series(data=None, dtype='float64')
lock.parsFitm1 = pd.Series(data=None, dtype='float64')
lock.Rtim = pd.Series(data=None, dtype='float64')
# run n simulations
run = 0
member = lock.copy()
# Config:
model = ep.SEIRModel(G)
# print(model.parameters)
# print(model.available_statuses)
config = mc.Configuration()
config.add_model_parameter('alpha', gamma)
config.add_model_parameter('beta', beta)
config.add_model_parameter('gamma', mu)
config.add_model_parameter("percentage_infected", 0.00011)
while run < lock.runs:
print("\n" + str(run + 1) + " of " + str(lock.runs))
model.set_initial_status(config)
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)
SI_trends = SIModel.build_trends(SI_iterations)
visualize(SIModel, SI_trends, sub_dir='epidemics')
SISModel = ep.SISModel(g.copy())
SISModel.set_initial_status(get_sis_params())
SIS_iterations = SISModel.iteration_bunch(num_iterations)
SIS_trends = SISModel.build_trends(SIS_iterations)
visualize(SISModel, SIS_trends, sub_dir='epidemics')
SEISModel = ep.SEISModel(g.copy())
SEISModel.set_initial_status(get_seis_params())
SEIS_iterations = SEISModel.iteration_bunch(num_iterations)
SEIS_trends = SEISModel.build_trends(SEIS_iterations)
visualize(SEISModel, SEIS_trends, sub_dir='epidemics')
SEIRModel = ep.SEIRModel(g.copy())
SEIRModel.set_initial_status(get_seir_params())
SEIR_iterations = SEIRModel.iteration_bunch(num_iterations)
SEIR_trends = SEIRModel.build_trends(SEIR_iterations)
visualize(SEIRModel, SEIR_trends, sub_dir='epidemics')
###############################################################
voter_model = op.VoterModel(g.copy())
voter_model.set_initial_status(get_voter_params())
voter_iterations = voter_model.iteration_bunch(num_iterations)
voter_trends = voter_model.build_trends(voter_iterations)
visualize(voter_model, voter_trends, sub_dir='opinions')
QVoter_model = op.QVoterModel(g.copy())
QVoter_model.set_initial_status(get_qvoter_params())
