def train(self):
self.death = self.load_dead(self.country)
self.recovered = self.load_recovered(self.country)
if self.cleanRecovered:
zeroRecDeaths = 0
else:
zeroRecDeaths = 1
self.data = self.load_confirmed(
self.country) - zeroRecDeaths * (self.recovered + self.death)
bounds = [(1e-12, .2), (1e-12, .2), (1 / 60, 0.4), (1 / 60, .4),
(1 / 60, .4), (1e-12, .4), (1e-12, .4), (1e-12, .4)]
maxiterations = 1500
f=create_lossOdeint(self.data, self.recovered, \
self.death, self.s_0, self.e_0, self.a_0, self.i_0, self.r_0, self.d_0, self.startNCases, \
self.weigthCases, self.weigthRecov)
de = DE(f, bounds, maxiters=maxiterations)
i = 0
with tqdm(total=maxiterations * 750) as pbar:
for step in de.geniterator():
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
pbar.update(i)
i += 1
p = best_params[0]
#parameter list for optimization
#beta, beta2, sigma, sigma2, sigma3, gamma, b, mu
beta, beta2, sigma, sigma2, sigma3, gamma, b, mu = p
new_index, extended_actual, extended_recovered, extended_death, y0, y1, y2, y3, y4, y5 \
= self.predict(beta, beta2, sigma, sigma2, sigma3, gamma, b, mu, \
self.data, self.recovered, self.death, self.country, self.s_0, \
self.e_0, self.a_0, self.i_0, self.r_0, self.d_0)
df = pd.DataFrame(
{
'Susceptible': y0,
'Exposed': y1,
'Asymptomatic': y2,
'Infected data': extended_actual,
'Infected': y3,
'Recovered': extended_recovered,
'Predicted Recovered': y4,
'Death data': extended_death,
'Predicted Deaths': y5
},
index=new_index)
df.to_pickle('./data/SEAIRD_sigmaOpt_' + self.country + '.pkl')
print(f"country={self.country}, beta={beta:.8f}, beta2={beta2:.8f}, 1/sigma={1/sigma:.8f},"+\
f" 1/sigma2={1/sigma2:.8f},1/sigma3={1/sigma3:.8f}, gamma={gamma:.8f}, b={b:.8f},"+\
f" mu={mu:.8f}, r_0:{(beta/gamma):.8f}")
print(self.country + " is done!")
def opt(country, e0, a0, r0, d0, date, version):
bounds = [(1e6,9e6),(0,15),(0,600),\
(0.1,0.7),(0.1,0.4)]
maxiterations = 600
f = create_fun(country, e0, a0, r0, d0, date, version)
de = DE(f, bounds, maxiters=maxiterations)
i = 0
with tqdm(total=maxiterations * 500) as pbar:
for step in de.geniterator():
try:
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
except:
print("error in function evaluation")
pbar.update(i)
i += 1
p = best_params[0]
return p
def opt(country, e0, a0, date, version, startNCases):
if country == "China":
dayInf = 0
else:
dayInf = -10
bounds=[(0.5e6,20e6),(dayInf,10),(0,1500),\
(0.01,0.7),(0.01,0.12),(-50e3,50e3),(0,1500)]
maxiterations = 1000
f = create_fun(country, e0, a0, date, version, startNCases)
de = DE(f, bounds, maxiters=maxiterations)
for step in de.geniterator():
try:
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
except:
print("error in function evaluation")
p = best_params[0]
return p
def train(self):
self.death = self.load_dead()
self.recovered = self.load_confirmed() * self.ratio
self.data = self.load_confirmed() - self.recovered - self.death
size = len(self.data) + 1
bounds = [(1e-16, .9), (1e-16, .9), (1e-16, .9),
(5, int(size * self.sigmoidTime + 0.5) - 5),
(int(size * self.sigmoidTime + 0.5) + 5, size - 5),
(1e-16, .9), (1e-16, 10), (1e-16, 10), (0, 10), (1e-16, 10),
(1e-16, 10)]
maxiterations = 4500
f = self.create_lossOdeint()
de = DE(f, bounds, maxiters=maxiterations) #,popsize=100)
i = 0
with tqdm(total=maxiterations * 1750 * maxiterations / 3500) as pbar:
for step in de.geniterator():
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
pbar.update(i)
i += 1
p = best_params[0]
if self.under:
f = self.create_lossSub(p)
bnds = ((.1, 4), (.1, 4))
x0 = [1, 1]
minimizer_kwargs = {"method": "L-BFGS-B", "bounds": bnds}
optimal = basinhopping(f,
x0,
minimizer_kwargs=minimizer_kwargs,
disp=True,
niter=30)
p2 = optimal.x
print("districtRegion {}".format(self.districtRegion))
print("under notifications cases {:.2f}".format(p2[0]))
print("under notifications deaths {:.2f}".format(p2[1]))
else:
p2 = [1, 1]
point = np.concatenate((p, p2))
today = datetime.today()
endDate = today + timedelta(days=-2)
self.end_date = datetime.strftime(endDate, '%Y-%m-%d')
self.death = self.load_dead()
self.recovered = self.load_confirmed() * self.ratio
self.data = self.load_confirmed() - self.recovered - self.death
new_index, y0, y1, y2, y3, y4, y5 = self.predict(point)
#prepare dataframe to export
dataFr = [y0, y1, y2, y3, y4, y5]
dataFr2 = np.array(dataFr).T
df = pd.DataFrame(data=dataFr2)
df.columns = [
'Susceptible', 'Exposed', 'Asymptomatic', 'Infected', 'Recovered',
'Deaths'
]
df.index = pd.date_range(start=new_index[0], end=new_index[-1])
df.index.name = 'date'
if self.savedata:
dR = self.strip_accents(self.districtRegion)
#save simulation results for comparison and use in another codes/routines
df.to_pickle('./data/SEAIRD_sigmaOpt_' + dR + self.version +
'.pkl')
df.to_csv('./results/data/SEAIRD_sigmaOpt_' + dR + self.version +
'.csv',
sep=",")
del dataFr, dataFr2, idx, norm_vector, best_params, df,\
new_index, y0, y1, y2, y3, y4, y5
return p
def train(self):
self.death = self.load_dead(self.country)
self.recovered = self.load_recovered(self.country)
if self.cleanRecovered:
zeroRecDeaths = 0
else:
zeroRecDeaths = 1
self.data = self.load_confirmed(
self.country) - zeroRecDeaths * (self.recovered + self.death)
out=[self.data, self.recovered, \
self.death, self.s_0, self.e_0, self.a_0, self.i_0, self.r_0, self.d_0, self.startNCases, \
self.weigthCases, self.weigthRecov]
with open('./data/data.pkl', 'wb') as f:
pickle.dump(out, f)
bounds = [(1e-12, .2), (1e-12, .2), (1 / 600, 0.4), (1 / 600, .4),
(1 / 600, .4), (1e-12, .4), (1e-12, .4), (1e-12, .4)]
maxiterations = 1500
de = DE(lossOdeint, bounds, maxiters=maxiterations)
i = 0
with tqdm(total=maxiterations * 1000) as pbar:
for step in de.geniterator():
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
pbar.update(i)
i += 1
p = best_params[0]
#parameter list for optimization
#beta, beta2, sigma, sigma2, sigma3, gamma, b, mu
beta, beta2, sigma, sigma2, sigma3, gamma, b, mu = p
new_index, extended_actual, extended_recovered, extended_death, y0, y1, y2, y3, y4, y5 \
= self.predict(beta, beta2, sigma, sigma2, sigma3, gamma, b, mu, \
self.data, self.recovered, self.death, self.country, self.s_0, \
self.e_0, self.a_0, self.i_0, self.r_0, self.d_0)
df = pd.DataFrame(
{
'Susceptible': y0,
'Exposed': y1,
'Asymptomatic': y2,
'Infected data': extended_actual,
'Infected': y3,
'Recovered': extended_recovered,
'Predicted Recovered': y4,
'Death data': extended_death,
'Predicted Deaths': y5
},
index=new_index)
plt.rc('font', size=14)
fig, ax = plt.subplots(figsize=(15, 10))
ax.set_title("Global Opt - SEAIR-D Model for " + self.country)
ax.set_ylim((0, max(y0) * 1.1))
df.plot(ax=ax) #,style=['-','-','-','o','-','x','-','s','-'])
print(f"country={self.country}, beta={beta:.8f}, beta2={beta2:.8f}, 1/sigma={1/sigma:.8f},"+\
f" 1/sigma2={1/sigma2:.8f},1/sigma3={1/sigma3:.8f}, gamma={gamma:.8f}, b={b:.8f},"+\
f" mu={mu:.8f}, r_0:{(beta/gamma):.8f}")
plt.annotate('Dr. Guilherme Araujo Lima da Silva, www.ats4i.com',
fontsize=10,
xy=(1.04, 0.1),
xycoords='axes fraction',
xytext=(0, 0),
textcoords='offset points',
ha='right',
rotation=90)
plt.annotate(
'Source: https://www.lewuathe.com/covid-19-dynamics-with-sir-model.html',
fontsize=10,
xy=(1.06, 0.1),
xycoords='axes fraction',
xytext=(0, 0),
textcoords='offset points',
ha='left',
rotation=90)
plt.annotate('Original SEAIR-D with delay model, São Paulo, Brazil',
fontsize=10,
xy=(1.045, 0.1),
xycoords='axes fraction',
xytext=(0, 0),
textcoords='offset points',
ha='left',
rotation=90)
df.to_pickle('./data/SEAIRD_sigmaOpt_' + self.country + '.pkl')
country = self.country
strFile = "./results/modelSEAIRDOptGlobalOptimum" + country + "Yabox.png"
savePlot(strFile)
plt.show()
plt.close()
plotX = new_index[range(0, self.predict_range)]
plotXt = new_index[range(0, len(extended_actual))]
fig, ax = plt.subplots(figsize=(15, 10))
ax.set_title("Zoom SEAIR-D Model for " + self.country)
plt.xticks(np.arange(0, self.predict_range, self.predict_range / 8))
ax.set_ylim(0, max(y3) * 1.1)
ax.plot(plotX, y3, 'y-', label="Infected")
ax.plot(plotX, y4, 'c-', label="Recovered")
ax.plot(plotX, y5, 'm-', label="Deaths")
ax.plot(plotXt, extended_actual, 'o', label="Infected data")
ax.plot(plotXt, extended_death, 'x', label="Death data")
ax.plot(plotXt, extended_recovered, 's', label="Recovered data")
ax.legend()
plt.annotate('Dr. Guilherme A. L. da Silva, www.ats4i.com',
fontsize=10,
xy=(1.04, 0.1),
xycoords='axes fraction',
xytext=(0, 0),
textcoords='offset points',
ha='right',
rotation=90)
plt.annotate('Original SEAIR-D with delay model, São Paulo, Brazil',
fontsize=10,
xy=(1.045, 0.1),
xycoords='axes fraction',
xytext=(0, 0),
textcoords='offset points',
ha='left',
rotation=90)
strFile = "./results/ZoomModelSEAIRDOpt" + country + "Yabox.png"
savePlot(strFile)
plt.show()
plt.close()
print(self.country + " is done!")
def train(self):
self.death = self.load_dead(self.country)
self.recovered = self.load_recovered(self.country)
self.data = self.load_confirmed(
self.country) - self.recovered - self.death
size = len(self.data)
bounds = [(1e-12, .2), (1e-12, .2), (5, size - 5), (1e-12, .2),
(1 / 160, 0.4), (1 / 160, .4), (1 / 160, .4), (1e-12, .4),
(1e-12, .4), (1e-12, .4), (1e-12, .4), (1e-12, .4)]
maxiterations = 5500
f=self.create_lossOdeint(self.data, \
self.death, self.recovered, self.s_0, self.e_0, self.a_0, self.i_0, self.r_0, self.d_0, self.startNCases, \
self.weigthCases, self.weigthRecov)
de = DE(f, bounds, maxiters=maxiterations) #,popsize=100)
i = 0
with tqdm(total=maxiterations * 1750 * maxiterations / 3500) as pbar:
for step in de.geniterator():
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
pbar.update(i)
i += 1
p = best_params[0]
#parameter list for optimization
beta0, beta01, startT, beta2, sigma, sigma2, sigma3, gamma, b, gamma2, d, mu = p
new_index, extended_actual, extended_death, extended_recovered, y0, y1, y2, y3, y4, y5 \
= self.predict(beta0, beta01, startT, beta2, sigma, sigma2, sigma3, gamma, b, gamma2, d, mu,\
self.data, self.death, self.recovered, self.country, self.s_0, \
self.e_0, self.a_0, self.i_0, self.r_0, self.d_0, self.predict_range)
#prepare dataframe to export
df = pd.DataFrame(
{
'Susceptible': y0,
'Exposed': y1,
'Asymptomatic': y2,
'Infected data': extended_actual,
'Infected': y3,
'Recovered': extended_recovered,
'Predicted Recovered': y4,
'Death data': extended_death,
'Predicted Deaths': y5
},
index=new_index)
if self.savedata:
#save simulation results for comparison and use in another codes/routines
df.to_pickle('./data/SEAIRDv5_Yabox_' + self.country + '.pkl')
df.to_csv('./results/data/SEAIRDv5_Yabox_' + self.country + '.csv',
sep=",")
del idx, norm_vector, best_params, df,\
new_index, extended_actual, extended_death, extended_recovered, y0, y1, y2, y3, y4, y5
return p
def train(self):
self.death = self.load_dead(self.country)
self.recovered = self.load_recovered(self.country)
if self.cleanRecovered:
zeroRecDeaths = 0
else:
zeroRecDeaths = 1
self.data = self.load_confirmed(
self.country) - zeroRecDeaths * (self.recovered + self.death)
size = len(self.data)
halfSize = int(round(size / 2))
bounds = [(1e-12, .2), (1e-12, .2), (5, halfSize), (1e-12, .2),
(halfSize + 1, size - 5), (1e-12, .2), (1 / 120, 0.4),
(1 / 120, .4), (1 / 120, .4), (1e-12, .4), (1e-12, .4),
(1e-12, .4), (1e-12, .4), (1e-12, .4), (0.05, 0.35)]
maxiterations = 2500
f=create_lossOdeint(self.data, self.recovered, \
self.death, self.s_0, self.e_0, self.a_0, self.i_0, self.r_0, \
self.d_0, self.startNCases, \
self.weigthCases, self.weigthRecov)
de = DE(f, bounds, maxiters=maxiterations)
i = 0
ndims = len(bounds)
with tqdm(total=maxiterations * ndims * 125) as pbar:
for step in de.geniterator():
idx = step.best_idx
norm_vector = step.population[idx]
best_params = de.denormalize([norm_vector])
pbar.update(i)
i += 1
p = best_params[0]
#parameter list for optimization
beta0, beta01, startT, beta02, startT2, beta2, sigma, sigma2, sigma3, gamma, b, mu, gamma2, d, p = p
new_index, extended_actual, extended_recovered, extended_death, y0, y1, y2, y3, y4, y5 \
= self.predict(beta0, beta01, startT, beta02, startT2, beta2, sigma, sigma2, sigma3, gamma, b, mu, gamma2, d, p, \
self.data, self.recovered, self.death, self.country, self.s_0, \
self.e_0, self.a_0, self.i_0, self.r_0, self.d_0)
df = pd.DataFrame(
{
'Susceptible': y0,
'Exposed': y1,
'Asymptomatic': y2,
'Infected data': extended_actual,
'Infected': y3,
'Recovered': extended_recovered,
'Predicted Recovered': y4,
'Death data': extended_death,
'Predicted Deaths': y5
},
index=new_index)
df.to_pickle('./data/SEAIRDv7_Yabox_' + self.country + '.pkl')
print(f"country={self.country}, beta0={beta0:.8f}, beta01={beta01:.8f}, startT={startT:.8f}, beta02={beta02:.8f}, startT2={startT2:.8f}, beta2={beta2:.8f}, 1/sigma={1/sigma:.8f},"+\
f" 1/sigma2={1/sigma2:.8f},1/sigma3={1/sigma3:.8f}, gamma={gamma:.8f}, b={b:.8f},"+\
f" gamma2={gamma2:.8f}, d={d:.8f}, mu={mu:.8f}, r_0:{((beta0+beta01)/gamma):.8f}")
print(self.country + " is done!")