def init_qsa (self): self.qsa_map[(State(-1, -1, -1), "DEAL")] = (0.0, 0) for action in ["HIT", "STICK"]: for i in xrange(32): for j in xrange(3): for k in xrange(1, 11): self.qsa_map[(State(i, j, k), action)] = (0.0, 0)
def plot_qsa (agent, file_path, figure_title):
fig = plt.figure()
fig.suptitle(figure_title)
for j in [0, 1, 2]:
s = "22" + str(j+1)
ax = fig.add_subplot(int(s), projection='3d')
X = np.array(range(0,32))
Y = np.array(range(1,11))
Z = np.zeros((10,32), dtype="float64")
for i in xrange(31):
for k in xrange(10):
Z[k][i] = max(agent.qsa_map[State(X[i], j, Y[k]), "HIT"][0], agent.qsa_map[State(X[i], j, Y[k]), "STICK"][0])
X,Y = np.meshgrid(X,Y)
ax.plot_wireframe(X,Y,Z, rstride=1, cstride=1)
ax.set_xlabel('Player hand value')
ax.set_ylabel('Dealer hand value')
ax.set_zlabel('q(s,a) value')
ax.view_init(45, 260)
if (j == 0):
ax.set_title("Hand value - No special card")
elif (j == 1):
ax.set_title("Hand value - Special card (Used at lower value)")
elif (j == 2):
ax.set_title("Hand value - Special card (Used at higher value)")
# plt.show()
fig = plt.gcf()
fig.set_size_inches(19.20,10.80)
plt.savefig(file_path,dpi=80)
def init_policy (self): self.policy[State(-1, -1, -1)] = "DEAL" for i in xrange(32): for j in xrange (3): for k in xrange (1,11): p1 = random.uniform(0,1) if (p1 < 0.5): self.policy[State(i, j, k)] = "HIT" else: self.policy[State(i, j, k)] = "STICK"
def next_state_reward (self, curr_state, action): if (curr_state == self.start_state): player_card = self.sim.get_card() dealer_card = self.sim.get_card() # player_card = 8 # dealer_card = 7 # print "Initial cards: " + str(player_card) + " " + str(dealer_card) if (player_card < 0 and dealer_card < 0): next_state = State (-1, 0, -1) reward = 0 EoE = True elif (player_card > 0 and dealer_card < 0): hand_value = player_card value_type = 0 if (player_card >= 1 and player_card <= 3): hand_value += 10 value_type = 2 next_state = State (hand_value, value_type, -1) reward = 100 EoE = True elif (player_card < 0 and dealer_card > 0): next_state = State (-1, 0, dealer_card) reward = -100 EoE = True else: hand_value = player_card value_type = 0 if (player_card >= 1 and player_card <= 3): hand_value += 10 value_type = 2 next_state = State (hand_value, value_type, dealer_card) reward = 0 EoE = False else: if (action == "HIT"): # print "Hitting..." next_state = self.sim.hit_update(curr_state) if (next_state.hand_value != -1): reward = 0 EoE = False else: reward = -100 EoE = True else : next_state = curr_state reward = self.sim.get_reward_stick(curr_state) EoE = True # print "Next state: " + str(next_state) # print "Reward: " + str(reward) # print "EoE: " + str(EoE) return (next_state, reward, EoE)
def test_set_outbreak():
state = State(regions, routes)
assert_equal(state.region_sir[1382].susceptible, 39132)
assert_equal(state.region_sir[1382].infected, 0)
assert_equal(state.region_sir[1382].removed, 0)
state.set_outbreak('Paris', 1000)
assert_equal(state.region_sir[1382].susceptible, 38132)
assert_equal(state.region_sir[1382].infected, 1000)
assert_equal(state.region_sir[1382].removed, 0)
def test_simulate():
state = State(regions, routes)
state.set_outbreak('Paris', 1000)
sim = Simulator(state)
total_population_pre = sim.state.total_sir().total_pop
sim.step()
total_population_post = sim.state.total_sir().total_pop
# check that transfers and disease spread didn't change the world
# population'
assert_equal(total_population_pre, total_population_post)
def print_policy (agent): for i in xrange(32): for j in xrange(3): for k in xrange(1, 11): if (State(i, j, k) in agent.policy): print str(i) + " | " + str(j) + " | " + str(k) + "\t ----------- " + agent.policy[State(i,j,k)] else: print str(i) + " | " + str(j) + " | " + str(k) + "\t ----------- Not found ----------------------------------------"
def print_qsa (agent): for action in ["HIT", "STICK"]: for i in xrange(32): for j in xrange(3): for k in xrange(1, 11): if (State(i, j, k), action) in agent.qsa_map: print str(i) + " | " + str(j) + " | " + str(k) + " | " + action + "\t ----------- " + str(agent.qsa_map[(State(i, j, k), action)][0]) + " | " + str(agent.qsa_map[(State(i, j, k), action)][1]) else: print str(i) + " | " + str(j) + " | " + str(k) + " | " + action + "\t ----------- Not found ----------------------------------------"
import _setup
import os.path as path
import time
from display import WorldMap
from simulator import State, Simulator
from world import regions, routes
this_dir = path.dirname(path.realpath(__file__))
len_simulation = 90
state = State(regions, routes, verbose=True)
state.set_outbreak('Rio De Janeiro', 1000)
sim = Simulator(
state,
transfer_prob=0.005,
beta=2,
gamma=0.5,
verbose=True,
)
sim.add_event(2560, days=18, total_transfer=380e3)
base_map = WorldMap(resolution="c")
base_map.animate(sim, frames=len_simulation, max_infected=0.1)
base_map.ani.save(path.join(this_dir, '../../report/plots/gifs/rio.mp4'),
writer="mencoder_file",
fps=3,
savefig_kwargs={'bbox_inches': 'tight'})
import _setup
from display import WorldMap
from simulator import State, Simulator
from world import regions, routes
state = State(regions, routes, verbose=True)
state.set_outbreak('Sidney', 1000)
sim = Simulator(state, transfer_prob=0.005, frames=400)
# plot regions on a world map
base_map = WorldMap(resolution="c")
base_map.animate(sim)
base_map.show()
import _setup
from display import WorldMap
from simulator import State, Simulator
from world import regions, routes
state = State(regions, routes, verbose=True)
state.set_outbreak('Rio De Janeiro', 1000)
# sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5, verbose=True)
# sim.add_event(2560, days=18, total_transfer=380e3)
# # plot regions on a world map
# base_map = WorldMap(resolution="c")
# base_map.animate(sim, frames=120, max_infected=0.1)
# base_map.show()
sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5, verbose=True)
# plot regions on a world map
base_map = WorldMap(resolution="c")
base_map.animate(sim, frames=120, max_infected=0.1)
base_map.show()
def transition(self, s, a):
s = s.action(a)
if type(s) == int:
return State(np.array([[0]*15+[1]])), s
else:
return s, 1
def execute_simulation(add_rio=False,
ol_start=0,
rio_length=18,
rio_visitors=380e3,
n_simulations=5):
sol_global = []
sol_rio = []
sol_moscow = []
sol_berlin = []
sol_beijing = []
sol_sydney = []
sol_new_york = []
params = {}
params['global'] = []
params['rio'] = []
params['moscow'] = []
params['berlin'] = []
params['beijing'] = []
params['sydney'] = []
params['new'] = []
for j in range(n_simulations):
print("running simulation {0} / {1}".format(j + 1, n_simulations))
state = State(regions, routes, verbose=True)
state.set_outbreak('Rio De Janeiro', 1e3) #'Rio De Janeiro', 1000)
sim = Simulator(state,
transfer_prob=0.005,
beta=2,
gamma=0.5,
verbose=True)
sol_global.append([])
sol_rio.append([])
sol_moscow.append([])
sol_berlin.append([])
sol_beijing.append([])
sol_sydney.append([])
sol_new_york.append([])
state_list = []
for i, state in enumerate(sim.run(iterations=120)):
state_list.append(state)
if i == ol_start and add_rio: # start outbreak x days before olympics
sim.add_event(2560,
days=rio_length,
total_transfer=rio_visitors)
sol_global[j].append(state.total_sir().as_tuple(total=True))
sol_rio[j].append(state.region_sir[2560].as_tuple(total=True))
sol_moscow[j].append(state.region_sir[4029].as_tuple(total=True))
sol_berlin[j].append(state.region_sir[351].as_tuple(total=True))
sol_beijing[j].append(state.region_sir[3364].as_tuple(total=True))
sol_sydney[j].append(state.region_sir[3361].as_tuple(total=True))
sol_new_york[j].append(state.region_sir[3797].as_tuple(total=True))
params['global'].append(
sir.ParameterEstimator(iter([x.total_sir() for x in state_list]),
method='max').beta)
params['rio'].append(
sir.ParameterEstimator(iter(
[x.region_sir[2560] for x in state_list]),
method='max').beta)
params['moscow'].append(
sir.ParameterEstimator(iter(
[x.region_sir[4029] for x in state_list]),
method='max').beta)
params['berlin'].append(
sir.ParameterEstimator(iter(
[x.region_sir[351] for x in state_list]),
method='max').beta)
params['beijing'].append(
sir.ParameterEstimator(iter(
[x.region_sir[3364] for x in state_list]),
method='max').beta)
params['sydney'].append(
sir.ParameterEstimator(iter(
[x.region_sir[3361] for x in state_list]),
method='max').beta)
params['new'].append(
sir.ParameterEstimator(iter(
[x.region_sir[2560] for x in state_list]),
method='max').beta)
if add_rio:
fig_name = "rio-{0}-{1}-{2:d}.pdf".format(ol_start, rio_length,
int(rio_visitors))
else:
fig_name = "no_rio.pdf"
plot_sir([
sol_global, sol_rio, sol_new_york, sol_berlin, sol_moscow, sol_beijing,
sol_sydney
], [
'Global', 'Rio De Janeiro', 'New York', 'Berlin', 'Moscow', 'Beijing',
'Sydney'
], fig_name)
# estimate means and variance
global_values = sol_global
peak_times_global = [np.argmax([x[1] for x in y]) for y in global_values]
peak_amount_global = [
y[peak][1] for peak, y in zip(peak_times_global, global_values)
]
peak_times_rio = [np.argmax([x[1] for x in y]) for y in sol_rio]
peak_times_new_york = [np.argmax([x[1] for x in y]) for y in sol_new_york]
peak_times_berlin = [np.argmax([x[1] for x in y]) for y in sol_berlin]
peak_times_moscow = [np.argmax([x[1] for x in y]) for y in sol_moscow]
peak_times_beijing = [np.argmax([x[1] for x in y]) for y in sol_beijing]
peak_times_sydney = [np.argmax([x[1] for x in y]) for y in sol_sydney]
t_deviations = scipy.stats.t.ppf(0.975, len(peak_times_rio) - 1)
# estimate variance with control variates
with open('control-{0}.csv'.format(add_rio), 'w') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
writer.writerow([
'global_amount', 'global_amount_control', 'global_peak_time',
'global_peak_time_control', 'rio_time', 'rio_time_control',
'new_york_time', 'new_york_time_control', 'berlin_time',
'berlin_time_control', 'moscow_time', 'moscow_time_control',
'beijing_time', 'beijing_time_control', 'sydney_time',
'sydney_time_control'
])
for i in range(n_simulations):
writer.writerow([
peak_amount_global[i], params['global'][i],
peak_times_global[i], params['global'][i], peak_times_rio[i],
params['rio'][i], peak_times_rio[i], params['new'][i],
peak_times_rio[i], params['berlin'][i], peak_times_rio[i],
params['moscow'][i], peak_times_rio[i], params['beijing'][i],
peak_times_rio[i], params['sydney'][i]
])
amount_global_control_conf = control_variate_conf(peak_amount_global,
params['global'])
time_global_control_conf = control_variate_conf(peak_times_global,
params['global'])
time_rio_control_conf = control_variate_conf(peak_times_rio, params['rio'])
time_new_york_control_conf = control_variate_conf(peak_times_new_york,
params['new'])
time_berlin_control_conf = control_variate_conf(peak_times_berlin,
params['berlin'])
time_moscow_control_conf = control_variate_conf(peak_times_moscow,
params['moscow'])
time_beijing_control_conf = control_variate_conf(peak_times_beijing,
params['beijing'])
time_sydney_control_conf = control_variate_conf(peak_times_sydney,
params['sydney'])
return [(np.mean(peak_amount_global), t_deviations *
np.std(peak_amount_global, ddof=1) / math.sqrt(n_simulations),
amount_global_control_conf),
(np.mean(peak_times_global), t_deviations *
np.std(peak_times_global, ddof=1) / math.sqrt(n_simulations),
time_global_control_conf),
(np.mean(peak_times_rio), t_deviations *
np.std(peak_times_rio, ddof=1) / math.sqrt(n_simulations),
time_rio_control_conf),
(np.mean(peak_times_new_york), t_deviations *
np.std(peak_times_new_york, ddof=1) / math.sqrt(n_simulations),
time_new_york_control_conf),
(np.mean(peak_times_berlin), t_deviations *
np.std(peak_times_berlin, ddof=1) / math.sqrt(n_simulations),
time_berlin_control_conf),
(np.mean(peak_times_moscow), t_deviations *
np.std(peak_times_moscow, ddof=1) / math.sqrt(n_simulations),
time_moscow_control_conf),
(np.mean(peak_times_beijing), t_deviations *
np.std(peak_times_beijing, ddof=1) / math.sqrt(n_simulations),
time_beijing_control_conf),
(np.mean(peak_times_sydney), t_deviations *
np.std(peak_times_sydney, ddof=1) / math.sqrt(n_simulations),
time_sydney_control_conf)]
import _setup
import scipy.stats
import math
import numpy as np
import sir
import world
from simulator import Simulator, State
import matplotlib.pyplot as plt
state = State(world.regions, world.routes)
state.set_outbreak('Paris', 1000)
# param_list = []
# for i in range(0, 25):
# print("run {0}".format(i))
# sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5, verbose=True)
# param_est = sir.ParameterEstimator(sim.run(iterations=120), method='max')
# param_list.append(str(param_est))
# for x in param_list:
# print(x)
sample_a = np.asarray([
# gamma, beta, N, I, max_infected, max_infected_i
[16.921686, 35.575031, 7399998550, 1000, 359733948, 53],
reward_arr.append(reward_avg)
line, = ax.plot(alpha_arr, reward_arr, linestyle='-', marker='^')
line.set_label('TD(Lambda)')
ax.legend()
ax.set_xlabel('Learning Rate')
ax.set_ylabel('Average reward over 100 test runs after training')
fig = plt.gcf()
fig.set_size_inches(19.20,10.80)
# plt.savefig('./graphs/Part3/' + str(100),dpi=80)
##################################################### P A R T 4 ###########################################################
if (lambda_policy):
EPISODES = 1000000
print ("Training TD Lambda for ", EPISODES, " episodes")
agent = Agent()
agent.init_qsa()
agent.init_policy()
agent.play_episode(policy_25=False, control=True, online=False, td_lambda=False, episodes=EPISODES, decay=False, alpha=0.1, k=1)
print ("Evaluating trained algorithm using Monte Carlo")
agent.init_qsa()
EPISODES = 1000000
agent.policy[State(-1, -1, -1)] = "DEAL"
for ep in xrange(EPISODES):
episode = agent.play_episode(policy_25=False, control=False, online=False)
monte_carlo_eval (agent, episode, False)
plot_qsa(agent, './graphs/Part4/eval', 'TD(Lambda) trained for 1 Million episodes')
def execute_simulation(add_rio=False, ol_start=0, rio_length=18,
rio_visitors=380e3, n_simulations=5):
sol_global = []
sol_rio = []
sol_moscow = []
sol_berlin = []
sol_beijing = []
sol_sydney = []
sol_new_york = []
params = {}
params['global'] = []
params['rio'] = []
params['moscow'] = []
params['berlin'] = []
params['beijing'] = []
params['sydney'] = []
params['new'] = []
for j in range(n_simulations):
print("running simulation {0} / {1}".format(j + 1, n_simulations))
state = State(regions, routes, verbose=True)
state.set_outbreak('Rio De Janeiro', 1e3)#'Rio De Janeiro', 1000)
sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5,
verbose=True)
sol_global.append([])
sol_rio.append([])
sol_moscow.append([])
sol_berlin.append([])
sol_beijing.append([])
sol_sydney.append([])
sol_new_york.append([])
state_list = []
for i, state in enumerate(sim.run(iterations=120)):
state_list.append(state)
if i == ol_start and add_rio: # start outbreak x days before olympics
sim.add_event(2560, days=rio_length, total_transfer=rio_visitors)
sol_global[j].append(state.total_sir().as_tuple(total=True))
sol_rio[j].append(state.region_sir[2560].as_tuple(total=True))
sol_moscow[j].append(state.region_sir[4029].as_tuple(total=True))
sol_berlin[j].append(state.region_sir[351].as_tuple(total=True))
sol_beijing[j].append(state.region_sir[3364].as_tuple(total=True))
sol_sydney[j].append(state.region_sir[3361].as_tuple(total=True))
sol_new_york[j].append(state.region_sir[3797].as_tuple(total=True))
params['global'].append(sir.ParameterEstimator(
iter([x.total_sir() for x in state_list]), method='max').beta)
params['rio'].append(sir.ParameterEstimator(
iter([x.region_sir[2560] for x in state_list]), method='max').beta)
params['moscow'].append(sir.ParameterEstimator(
iter([x.region_sir[4029] for x in state_list]), method='max').beta)
params['berlin'].append(sir.ParameterEstimator(
iter([x.region_sir[351] for x in state_list]), method='max').beta)
params['beijing'].append(sir.ParameterEstimator(
iter([x.region_sir[3364] for x in state_list]), method='max').beta)
params['sydney'].append(sir.ParameterEstimator(
iter([x.region_sir[3361] for x in state_list]), method='max').beta)
params['new'].append(sir.ParameterEstimator(
iter([x.region_sir[2560] for x in state_list]), method='max').beta)
if add_rio:
fig_name = "rio-{0}-{1}-{2:d}.pdf".format(ol_start, rio_length,
int(rio_visitors))
else:
fig_name = "no_rio.pdf"
plot_sir([sol_global, sol_rio, sol_new_york, sol_berlin,
sol_moscow, sol_beijing, sol_sydney],
['Global', 'Rio De Janeiro', 'New York', 'Berlin',
'Moscow', 'Beijing', 'Sydney'], fig_name)
# estimate means and variance
global_values = sol_global
peak_times_global = [np.argmax([x[1] for x in y])
for y in global_values]
peak_amount_global = [y[peak][1]
for peak, y in zip(peak_times_global, global_values)]
peak_times_rio = [np.argmax([x[1] for x in y])
for y in sol_rio]
peak_times_new_york = [np.argmax([x[1] for x in y])
for y in sol_new_york]
peak_times_berlin = [np.argmax([x[1] for x in y])
for y in sol_berlin]
peak_times_moscow = [np.argmax([x[1] for x in y])
for y in sol_moscow]
peak_times_beijing = [np.argmax([x[1] for x in y])
for y in sol_beijing]
peak_times_sydney = [np.argmax([x[1] for x in y])
for y in sol_sydney]
t_deviations = scipy.stats.t.ppf(0.975, len(peak_times_rio)-1)
# estimate variance with control variates
with open('control-{0}.csv'.format(add_rio), 'w') as csvfile:
writer = csv.writer(csvfile, delimiter=',')
writer.writerow(['global_amount', 'global_amount_control',
'global_peak_time', 'global_peak_time_control',
'rio_time', 'rio_time_control',
'new_york_time', 'new_york_time_control',
'berlin_time', 'berlin_time_control',
'moscow_time', 'moscow_time_control',
'beijing_time', 'beijing_time_control',
'sydney_time', 'sydney_time_control'])
for i in range(n_simulations):
writer.writerow([peak_amount_global[i], params['global'][i],
peak_times_global[i], params['global'][i],
peak_times_rio[i], params['rio'][i],
peak_times_rio[i], params['new'][i],
peak_times_rio[i], params['berlin'][i],
peak_times_rio[i], params['moscow'][i],
peak_times_rio[i], params['beijing'][i],
peak_times_rio[i], params['sydney'][i]
])
amount_global_control_conf = control_variate_conf(peak_amount_global, params['global'])
time_global_control_conf = control_variate_conf(peak_times_global, params['global'])
time_rio_control_conf = control_variate_conf(peak_times_rio, params['rio'])
time_new_york_control_conf = control_variate_conf(peak_times_new_york, params['new'])
time_berlin_control_conf = control_variate_conf(peak_times_berlin, params['berlin'])
time_moscow_control_conf = control_variate_conf(peak_times_moscow, params['moscow'])
time_beijing_control_conf = control_variate_conf(peak_times_beijing, params['beijing'])
time_sydney_control_conf = control_variate_conf(peak_times_sydney, params['sydney'])
return [(np.mean(peak_amount_global),
t_deviations * np.std(peak_amount_global, ddof=1) / math.sqrt(n_simulations),
amount_global_control_conf),
(np.mean(peak_times_global),
t_deviations * np.std(peak_times_global, ddof=1) / math.sqrt(n_simulations),
time_global_control_conf),
(np.mean(peak_times_rio),
t_deviations * np.std(peak_times_rio, ddof=1) / math.sqrt(n_simulations),
time_rio_control_conf),
(np.mean(peak_times_new_york),
t_deviations * np.std(peak_times_new_york, ddof=1) / math.sqrt(n_simulations),
time_new_york_control_conf),
(np.mean(peak_times_berlin),
t_deviations * np.std(peak_times_berlin, ddof=1) / math.sqrt(n_simulations),
time_berlin_control_conf),
(np.mean(peak_times_moscow),
t_deviations * np.std(peak_times_moscow, ddof=1) / math.sqrt(n_simulations),
time_moscow_control_conf),
(np.mean(peak_times_beijing),
t_deviations * np.std(peak_times_beijing, ddof=1) / math.sqrt(n_simulations),
time_beijing_control_conf),
(np.mean(peak_times_sydney),
t_deviations * np.std(peak_times_sydney, ddof=1) / math.sqrt(n_simulations),
time_sydney_control_conf)
]
from learn import Learner
from simulator import State
import numpy as np
if __name__ == '__main__':
state = State(80, [[(100, 1, 2, 0.05, 0.5), (200, -1, 1, -0.05, 0.5)],
[(200, 0, 3, 0, 0.5),
(200, -1, 1, -0.05, 0.5)], [(300, 1, 2, 0.0, 0.5)]],
(0.95, 1),
debug=False)
learner = Learner(state,
alpha=0.05,
gamma=0.9,
exploration_param=1.0,
decay_param=0.2,
local_approx=True)
# 10
# learner.train(10)
# print learner.evaluate(100)
# # 100
# learner.train(90)
# print learner.evaluate(100)
# # 250
# learner.train(150)
# print learner.evaluate(100)
# # 500
# learner.train(250)
# print learner.evaluate(100)
# # 750
# learner.train(250)
def __init__(self, p=2.0/3): self.sim = Simulator(p) self.start_state = State (-1, -1, -1)
import _setup
import numpy as np
import scipy.stats
import matplotlib.pyplot as plt
from simulator import State, Simulator
from world import regions, routes
if __name__ == "__main__":
DO_PLOT = True
if DO_PLOT:
plt.figure()
for i in range(0, 1):
print('run {0:d}'.format(i))
state = State(regions, routes, verbose=True)
state.set_outbreak('Sidney', 1000)
sim = Simulator(state,
transfer_prob=0.005,
beta=2,
gamma=0.5,
verbose=True)
sol = []
for state in sim.run(iterations=120):
sol.append(state.total_sir().as_tuple(total=True))
#sol.append(state.region_sir[4029].as_tuple(total=True))
sol = np.asarray(sol)
if DO_PLOT:
- beta / sum(Y[6:]) * Y[7] * Y[6] + tau * (Y[3]-Y[6]),
beta / sum(Y[6:]) * Y[7] * Y[6] - gamma * Y[7] + tau * (Y[4]-Y[7]),
gamma * Y[7] + tau * (Y[5] - Y[8])]
start_infection_n1 = 2 / 50
t = np.arange(0, 365, 1)
asol = 100 * integrate.odeint(solver, [1 - R0, R0, 0,
1, 0, 0,
1, 0, 0], t)
plt.plot(t, asol[:, 1], ls='-', color='black', alpha=0.8, lw=2)
plt.plot(t, asol[:, 4], ls='-', color='black', alpha=0.8, lw=2)
ptrue, = plt.plot(t, asol[:, 7], ls='-', color='black', alpha=0.8, lw=2)
for i in range(0, 10):
state = State(regions, routes, verbose=True)
state.set_outbreak('Region 0', R0 * N)
sim = Simulator(state, transfer_prob=tau, beta=beta, gamma=gamma, verbose=True)
solution = np.zeros((365+1, 9))
for i, state in enumerate(sim.run(iterations=365)):
print(i)
for region_id, sir in state.region_sir.items():
print(str(sir))
solution[i, region_id * 3 + 0] = state.region_sir[region_id].susceptible / N
solution[i, region_id * 3 + 1] = state.region_sir[region_id].infected / N
solution[i, region_id * 3 + 2] = state.region_sir[region_id].removed / N
asol = np.asarray(solution) * 100
t = np.arange(0, asol.shape[0])
import _setup
import numpy as np
import scipy.stats
import matplotlib.pyplot as plt
from simulator import State, Simulator
from world import regions, routes
if __name__ == "__main__":
DO_PLOT = True
if DO_PLOT:
plt.figure()
for i in range(0, 1):
print('run {0:d}'.format(i))
state = State(regions, routes, verbose=True)
state.set_outbreak('Sidney', 1000)
sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5, verbose=True)
sol = []
for state in sim.run(iterations=120):
sol.append(state.total_sir().as_tuple(total=True))
#sol.append(state.region_sir[4029].as_tuple(total=True))
sol = np.asarray(sol)
if DO_PLOT:
p1, = plt.plot(sol[:, 0], color='SteelBlue', alpha=0.5, label='Susceptible')
p2, = plt.plot(sol[:, 1], color='IndianRed', alpha=0.5, label='Infected')
p3, = plt.plot(sol[:, 2], color='Olive', alpha=0.5, label='Removed')
import _setup
import scipy.stats
import math
import numpy as np
import sir
import world
from simulator import Simulator, State
import matplotlib.pyplot as plt
state = State(world.regions, world.routes)
state.set_outbreak('Paris', 1000)
# param_list = []
# for i in range(0, 25):
# print("run {0}".format(i))
# sim = Simulator(state, transfer_prob=0.005, beta=2, gamma=0.5, verbose=True)
# param_est = sir.ParameterEstimator(sim.run(iterations=120), method='max')
# param_list.append(str(param_est))
# for x in param_list:
# print(x)
sample_a = np.asarray([
# gamma, beta, N, I, max_infected, max_infected_i
[16.921686, 35.575031, 7399998550, 1000, 359733948, 53],
[16.725976, 35.164427, 7399998550, 1000, 363948376, 53],
[16.994056, 35.727980, 7399998550, 1000, 358206776, 53],
[16.858108, 35.434701, 7399998550, 1000, 361050212, 53],
[16.680545, 35.065132, 7399998550, 1000, 364916209, 53],
