def test_comp_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)
model1 = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.02)
config.add_model_parameter('gamma', 0.01)
config.add_model_parameter("percentage_infected", 0.06)
model1.set_initial_status(config)
iterations = model1.iteration_bunch(1000)
trends1 = model.build_trends(iterations)
# Visualization
viz = PhasePlaneComparison([model, model1], [trends, trends1],
x="Susceptible",
y="Infected")
viz.plot("diffusion.pdf")
os.remove("diffusion.pdf")
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 func_obj(x, g):
days = 30
sirSj = list()
sirS = list()
sirI = list()
sirR = list()
Igerado = list()
Rgerado = list()
# Ready CSV
arq = open("casos_sj2.csv")
sirSjCsv = csv.DictReader(arq, fieldnames=["S", "I", "R"])
i = 0
for row in sirSjCsv:
sirSj.insert(i, {
"S": int(row['S']),
"I": int(row['I']),
"R": int(row['R'])
})
sirS.append(int(row['S']))
sirI.append(int(row['I']))
sirR.append(int(row['R']))
i += 1
# Model selection
SIRModel = ep.SIRModel(g)
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.3)
cfg.add_model_parameter('gamma', 0.05)
cfg.add_model_parameter("fraction_infected", 0.008)
SIRModel.set_initial_status(cfg)
SIRModel.reset()
cfg.add_model_parameter('beta', x[0])
cfg.add_model_parameter('gamma', x[1])
cfg.add_model_parameter("fraction_infected", 0.08)
SIRModel.set_initial_status(cfg)
iterations = SIRModel.iteration_bunch(days)
#print(iterations)
a = 0
Igerado.clear()
Rgerado.clear()
matriz_gerada = np.zeros((days, 3), dtype=np.int)
for v in iterations:
matriz_gerada[a][0] = v['node_count'][0]
matriz_gerada[a][1] = v['node_count'][1]
matriz_gerada[a][2] = v['node_count'][2]
Igerado.append(v['node_count'][1])
Rgerado.append(v['node_count'][2])
a = a + 1
print(iterations)
mseI = mean_squared_error(sirI, Igerado)
mseR = mean_squared_error(sirR, Rgerado)
rmseI = math.sqrt(mseI)
rmseR = math.sqrt(mseR)
f = (rmseI + rmseR) / 2
return f
def test_trend_comparison(self):
# Network topology
g = nx.erdos_renyi_graph(1000, 0.1)
# Model selection
model = epd.SIRModel(g)
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.001)
cfg.add_model_parameter('gamma', 0.02)
cfg.add_model_parameter("percentage_infected", 0.01)
model.set_initial_status(cfg)
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
model1 = epd.SIModel(g)
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.001)
cfg.add_model_parameter("percentage_infected", 0.01)
model1.set_initial_status(cfg)
iterations = model1.iteration_bunch(200)
trends1 = model1.build_trends(iterations)
viz = DiffusionTrendComparison([model, model1], [trends, trends1])
viz.plot("trend_comparison.pdf")
os.remove("trend_comparison.pdf")
def simulate_sir_on_network(G):
# Model Configuration
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.05)
cfg.add_model_parameter('gamma', 0.05)
cfg.add_model_initial_configuration("Infected", random.sample(G.nodes,
k=5))
# Model selection
model = ep.SIRModel(G)
# Initialize the simulation
model.set_initial_status(cfg)
Si, Ii, Ri = [], [], []
for s in range(SIMULCOUNT):
# Reset the model
model.reset()
# Simulation execution
iterations = model.iteration_bunch(ITERCOUNT)
# Collect results for figures
S, I, R = [], [], []
for i in range(ITERCOUNT):
iteration = iterations[i]['node_count']
S.append(iteration[0] / G.number_of_nodes())
I.append(iteration[1] / G.number_of_nodes())
R.append(iteration[2] / G.number_of_nodes())
Si.append(S)
Ii.append(I)
Ri.append(R)
plot_spreading_figures(Si, Ii, Ri)
def test_sir_model(self):
for g in get_graph(True):
model = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 0.2)
config.add_model_parameter("percentage_infected", 0.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)
def test_sir_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.SIRModel(g)
config = mc.Configuration()
config.add_model_parameter('beta', 0.5)
config.add_model_parameter('gamma', 0.2)
config.add_model_parameter("fraction_infected", 0.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)
def test_visualize_prevalence(self):
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)
p = viz.plot()
self.assertIsInstance(p, Figure)
def test_visualize(self):
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)
# Visualization
viz = DiffusionTrend(model, trends)
viz.plot("diffusion.pdf")
os.remove("diffusion.pdf")
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)
import networkx as nx
import ndlib.models.epidemics as ep
import ndlib.models.ModelConfig as mc
from bokeh.io import output_notebook, show
from ndlib.viz.bokeh.DiffusionTrend import DiffusionTrend
from ndlib.viz.bokeh.DiffusionPrevalence import DiffusionPrevalence
from ndlib.viz.bokeh.MultiPlot import MultiPlot
import ndlib.models.epidemics.SISModel as sis
import ndlib.models.epidemics.SIModel as si
import ndlib.models.epidemics.ThresholdModel as th
# Network Definition
g = nx.erdos_renyi_graph(1000, 0.1)
# Model Selection
model = ep.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)
model.set_initial_status(config)
# Simulation
iterations = model.iteration_bunch(200)
trends = model.build_trends(iterations)
viz = DiffusionTrend(model, trends)
p = viz.plot(width=400, height=400)
show(p)
import networkx as nx
import matplotlib.pyplot as plt
import ndlib.models.ModelConfig as mc
import ndlib.models.epidemics as ep
# Variables
N = 100
m = 3
iter_count = 1000
# Initiate Graph
G = nx.barabasi_albert_graph(N, m)
pos = nx.spring_layout(G)
# SIR Model
model = ep.SIRModel(G)
# Model Config
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.01)
cfg.add_model_parameter('gamma', 0.005)
cfg.add_model_parameter('fraction_infected', 0.05) # Initial Fraction Infected
model.set_initial_status(cfg)
# Lists for simulation and plotting
t = []
S = []
I = []
R = []
color_map = []
default=200,
help="Steps of simulation")
parser.add_argument("--beta",
type=float,
default=0.05,
help="Infection rate")
parser.add_argument("--gamma",
type=float,
default=0.005,
help="Death rate")
parser.add_argument("--out_file", help="Out file filename")
args = parser.parse_args()
network = loadmat(args.dataset)["graph"]
graph = nx.from_scipy_sparse_matrix(network)
model = ep.SIRModel(graph)
cfg = mc.Configuration()
cfg.add_model_parameter('beta', args.beta)
cfg.add_model_parameter('gamma', args.gamma)
model.set_initial_status(cfg)
with open(args.out_file, "w") as file:
for i in range(network.shape[0]):
for j in range(args.num_sims):
model.reset([i])
iterations = model.iteration_bunch(args.iters)
trends = model.build_trends(iterations)
data = trends[0]['trends']['node_count'][1]
max_point = np.argmax(data)
file.write(str(max_point) + " " + str(data[max_point]) + "\n")
import matplotlib.pyplot as plt
import networkx as nx
import json
import warnings
n = 271269 # n nodes
p = 0.007286
w = [p * n for i in range(n)] # w = p*n for all nodes
g = expected_degree_graph(w) # configuration model
largest_subgraph1 = max(nx.connected_component_subgraphs(g), key=len)
pos = nx.spring_layout(largest_subgraph1, k=0.05)
nx.draw(largest_subgraph1, pos=pos, cmap=plt.cm.PiYG, edge_color="black", linewidths=0.3, node_size=60, alpha=0.6, with_labels=False)
nx.draw_networkx(largest_subgraph1, pos=pos)
plt.savefig('graphfinal2.png')
model = ep.SIRModel(largest_subgraph1)
cfg = mc.Configuration()
cfg.add_model_parameter('beta', 0.05) # infection rate
cfg.add_model_parameter('gamma', 0.05) # recovery rate
cfg.add_model_parameter("percentage_infected", 0.01)
model.set_initial_status(cfg)
iterations = model.iteration_bunch(200, node_status=True)
trends = model.build_trends(iterations)
viz = DiffusionTrend(model, trends)
viz.plot()
viz = DiffusionPrevalence(model, trends)
viz.plot()
