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 test_compartment_swap_edge(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")
a1 = act.SwapEdges(probability=1,
number_of_swaps=1,
copy_attributes=True,
initial_status="Susceptible")
c1 = cmp.NodeStochastic(0.5)
model.add_rule("Susceptible", "Susceptible", c1)
model.add_action(a1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0)
model.set_initial_status(config)
iterations = model.iteration_bunch(6)
self.assertEqual(len(iterations), 6)
def test_compartment_add_node_pa(self):
g = nx.karate_club_graph()
attr = {n: {"even": int(n % 2)} for n in g.nodes()}
nx.set_node_attributes(g, attr)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
a1 = act.AddNode(probability=1,
initial_status="Susceptible",
copy_attributes=True,
number_of_edges=4,
model='PA')
c1 = cmp.NodeStochastic(1)
model.add_rule("Susceptible", "Susceptible", c1)
model.add_action(a1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0)
model.set_initial_status(config)
iterations = model.iteration_bunch(6)
nodes = [sum(n['node_count'].values()) for n in iterations]
self.assertEqual(nodes, [35, 36, 37, 38, 39, 40])
def test_compartment_add_node(self):
g = nx.karate_club_graph()
attr = {n: {"even": int(n % 2)} for n in g.nodes()}
nx.set_node_attributes(g, attr)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c2 = act.AddNode(probability=1,
initial_status="Susceptible",
copy_attributes=True)
c1 = cpm.NodeStochastic(1, composed=c2)
model.add_rule("Susceptible", "Susceptible", c1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0)
model.set_initial_status(config)
iterations = model.iteration_bunch(6)
nodes = [sum(n['node_count'].values()) for n in iterations]
self.assertEqual(nodes, [34, 67, 133, 265, 529, 1057])
def test_save_file(self):
def update(node, graph, status, attributes, constants):
return 0
initial_status = {'status': 0}
# Network definition
g = nx.erdos_renyi_graph(n=10, p=0.5)
# Model definition
path = './test_output/'
output_path = path + 'file'
with self.assertRaises(ValueError):
model = gc.ContinuousModel(g, save_file=5)
model = gc.ContinuousModel(g, save_file=output_path)
model.add_status('status')
# Compartments
condition = cpm.NodeStochastic(1)
# Rules
model.add_rule('status_1', update, condition)
# Configuration
config = mc.Configuration()
model.set_initial_status(initial_status, config)
# Simulation
iterations = model.iteration_bunch(10,
node_status=True,
progress_bar=False)
self.assertEqual(len(iterations), 10)
self.assertTrue(os.path.isfile(output_path + '.npy'))
os.remove(output_path + '.npy')
os.rmdir(path)
def test_conditions(self):
g = nx.erdos_renyi_graph(n=100, p=0.1)
model = gc.ContinuousModel(g)
model.add_status('status_1')
model.add_status('status_2')
# Compartments
condition = cpm.NodeStochastic(1)
# Update functions
def update_1(node, graph, status, attributes, constants):
return status[node]['status_2'] + 0.1
def update_2(node, graph, status, attributes, constants):
return status[node]['status_1'] + 0.5
# Rules
model.add_rule('status_1', update_1, condition)
model.add_rule('status_2', update_2, condition)
self.assertEqual(model.compartment_progressive, 2)
self.assertEqual(model.compartment[0],
('status_1', update_1, condition, ['']))
self.assertEqual(model.compartment[1],
('status_2', update_2, condition, ['']))
def test_schemes(self):
g = nx.erdos_renyi_graph(n=100, p=0.1)
# Define schemes
def sample_state_weighted(graph, status):
probs = []
status_1 = [stat['status_1'] for stat in list(status.values())]
factor = 1.0 / sum(status_1)
for s in status_1:
probs.append(s * factor)
return np.random.choice(graph.nodes,
size=1,
replace=False,
p=probs)
schemes = [{
'name': 'random weighted agent',
'function': sample_state_weighted,
'lower': 100,
'upper': 200
}]
model = gc.ContinuousModel(g, iteration_schemes=schemes)
model.add_status('status_1')
model.add_status('status_2')
# Compartments
condition = cpm.NodeStochastic(1)
# Update functions
def update_1(node, graph, status, attributes, constants):
return status[node]['status_2'] + 0.1
def update_2(node, graph, status, attributes, constants):
return status[node]['status_1'] + 0.5
# Rules
model.add_rule('status_1', update_1, condition,
['random weighted agent'])
model.add_rule('status_2', update_2, condition)
self.assertEqual(model.compartment_progressive, 2)
self.assertEqual(
model.compartment[0],
('status_1', update_1, condition, ['random weighted agent']))
self.assertEqual(model.compartment[1],
('status_2', update_2, condition, ['']))
self.assertTrue({
'name': 'random weighted agent',
'function': sample_state_weighted,
'lower': 100,
'upper': 200
} in model.iteration_schemes)
def test_node_stochastic_composed(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
model.add_status("Removed")
# cascading composition
c3 = cpm.NodeStochastic(0.2)
c2 = cpm.NodeStochastic(0.4, composed=c3)
c1 = cpm.NodeStochastic(0.5, "Infected", composed=c2)
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(100)
self.assertEqual(len(iterations), 100)
def test_node_stochastic(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = gc.CompositeModel(g)
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('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(100)
self.assertEqual(len(iterations), 100)
def test_conditional_composition(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
model.add_status("Removed")
# conditional composition
c1 = cpm.NodeStochastic(0.5)
c2 = cpm.NodeStochastic(0.2)
c3 = cpm.NodeStochastic(0.1)
cc = cpm.ConditionalComposition(c1, c2, c3)
model.add_rule("Susceptible", "Infected", cc)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(100)
self.assertEqual(len(iterations), 100)
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_runner_sa(self):
g = nx.erdos_renyi_graph(n=10, p=0.5)
constants = {'constant_1': 0.5, 'constant_2': 0.8}
def initial_status_1(node, graph, status, constants):
return np.random.uniform(0, 0.5)
def initial_status_2(node, graph, status, constants):
return status['status_1'] + np.random.uniform(0.5, 1)
initial_status = {
'status_1': initial_status_1,
'status_2': initial_status_2,
}
model = gc.ContinuousModel(g, constants=constants)
model.add_status('status_1')
model.add_status('status_2')
# Compartments
condition = cpm.NodeStochastic(1)
# Update functions
def update_1(node, graph, status, attributes, constants):
return status[node]['status_2'] * constants['constant_1']
def update_2(node, graph, status, attributes, constants):
return status[node]['status_1'] + constants['constant_2']
# Rules
model.add_rule('status_1', update_1, condition)
model.add_rule('status_2', update_2, condition)
config = mc.Configuration()
model.set_initial_status(initial_status, config)
# Simulation
runner = gcr.ContinuousModelRunner(model, config)
analysis = runner.analyze_sensitivity(SAType.MEAN, initial_status, {
'constant_1': (0, 1),
'constant_2': (-1, 1)
}, 1, 1)
self.assertEqual(len(analysis.keys()), 2)
def test_compartment_remove_node(self):
g = nx.karate_club_graph()
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
c2 = act.RemoveNode(probability=1)
c1 = cpm.NodeStochastic(1, composed=c2)
model.add_rule("Susceptible", "Susceptible", c1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0)
model.set_initial_status(config)
iterations = model.iteration_bunch(6)
nodes = [sum(n['node_count'].values()) for n in iterations]
self.assertEqual(nodes, [34, 1, 1, 1, 1, 1])
def test_compartment_remove_node_bottom(self):
g = nx.karate_club_graph()
model = gc.CompositeModel(g)
model.add_status("Susceptible")
model.add_status("Infected")
a1 = act.RemoveNode(probability=1, model="bottom")
c1 = cmp.NodeStochastic(0.5)
model.add_rule("Susceptible", "Susceptible", c1)
model.add_action(a1)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0)
model.set_initial_status(config)
iterations = model.iteration_bunch(6)
nodes = [sum(n['node_count'].values()) for n in iterations]
self.assertEqual(nodes, [33, 32, 31, 30, 29, 28])
def test_runner(self):
g = nx.erdos_renyi_graph(n=1000, p=0.1)
def initial_status_1(node, graph, status, constants):
return np.random.uniform(0, 0.5)
def initial_status_2(node, graph, status, constants):
return status['status_1'] + np.random.uniform(0.5, 1)
initial_status = {
'status_1': initial_status_1,
'status_2': initial_status_2,
}
model = gc.ContinuousModel(g)
model.add_status('status_1')
model.add_status('status_2')
# Compartments
condition = cpm.NodeStochastic(1)
# Update functions
def update_1(node, graph, status, attributes, constants):
return status[node]['status_2'] + 0.1
def update_2(node, graph, status, attributes, constants):
return status[node]['status_1'] + 0.5
# Rules
model.add_rule('status_1', update_1, condition)
model.add_rule('status_2', update_2, condition)
config = mc.Configuration()
model.set_initial_status(initial_status, config)
# Simulation
runner = gcr.ContinuousModelRunner(model, config)
results = runner.run(2, [1], [initial_status])
self.assertEqual(len(results), 2)
model.add_status("Symptomatic")
#model.add_status("Asymptomatic")
model.add_status("Infected")
model.add_status("Removed")
#-----------------------------------------------------
#DISEASE DATA
r0 = 3.1
disease_length = 14
people_total = 12 * disease_length
chance_of_infection = r0 / people_total
infect_chance = chance_of_infection
#print(infect_chance)
#-----------------------------------------------------
# Compartment Definition
c1_1 = ns.NodeStochastic(infect_chance, triggering_status="Infected")
c1_3 = ns.NodeStochastic(infect_chance, triggering_status="Symptomatic")
c2_1 = ns.NodeStochastic((1 - 0.5**(1/11)))
c3 = ns.NodeStochastic((1 - 0.5**(1/14)))
c4 = ns.CountDown('Testing Timer', iterations = itercount)
# 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)
