def test_covid_sir(self):
model = CovidSIRDc()
rst = model.to_rst()
self.assertIn('\\frac', rst)
self.assertIn('I', rst)
par = model.get()
self.assertIn('I', par)
p = {'I': 5.}
model.update(**p)
par = model.get()
self.assertEqual(par['I'], 5.)
dot = model.to_dot(verbose=True)
self.assertIn("I -> R", dot)
self.assertNotIn("I -> I", dot)
self.assertIn('beta', dot)
self.assertNotIn('-beta', dot)
dot = model.to_dot(verbose=True, full=True)
self.assertIn("I -> I", dot)
self.assertIn('-beta', dot)
model['beta'] = 0.5
self.assertEqual(model['beta'], 0.5)
model['N'] = 100000
self.assertEqual(model['N'], 100000)
ht = model._repr_html_()
self.assertIn("{equation}", ht)
def test_covid_sir_loop(self):
model = CovidSIRDc()
sim = list(model.iterate())
self.assertEqual(len(sim), 10)
self.assertGreater(sim[-1]['S'], 9500)
self.assertLess(sim[-1]['S'], 10000)
r0 = model.R0()
self.assertEqual(r0, 4.2)
def test_prefit(self):
model = CovidSIRDc()
losses = model._losses_sympy()
self.assertIsInstance(losses, list)
self.assertEqual(len(losses), 4)
grads = model._grads_sympy()
self.assertIsInstance(grads, list)
for row in grads:
self.assertIsInstance(row, list)
self.assertEqual(len(row), 6)
def test_noise(self):
model = CovidSIRDc()
X, y = model.iterate2array(derivatives=True)
X2 = model.add_noise(X)
diff = numpy.abs(X - X2).max()
self.assertEqual(X.shape, X.shape)
s1 = numpy.sum(X, axis=1)
s2 = numpy.sum(X2, axis=1)
assert_almost_equal(s1, s2)
self.assertGreater(diff, 1)
def test_fit_sirc_simulate(self):
model = CovidSIRDc()
X, y = model.iterate2array(derivatives=True)
epi = EpidemicRegressor('sirc', max_iter=10)
epi.fit(X, y)
sim = epi.simulate(X[4:6])
self.assertEqual(sim.shape, (2, 7, 4))
self.assertEqual(X[4].tolist(), sim[0, 0].tolist())
self.assertEqual(X[5].tolist(), sim[1, 0].tolist())
sim = epi.simulate(numpy.array([[10000., 0, 0, 0]]))
self.assertEqual(sim[0].tolist(), sim[-1].tolist())
def test_fit_sirc(self):
model = CovidSIRDc()
X, y = model.iterate2array(derivatives=True)
epi = EpidemicRegressor('sirc', max_iter=10)
with self.assertRaises(RuntimeError):
epi.score(X, y)
with self.assertRaises(RuntimeError):
epi.predict(X)
epi.fit(X, y)
loss = epi.score(X, y)
self.assertGreater(loss, 0)
def test_covid_sir_eval(self):
model = CovidSIRDc()
cst = model.cst_param
self.assertEqual(
cst, {
'N': 10000.0,
'beta': 0.5,
'mu': 0.07142857142857142,
'nu': 0.047619047619047616,
'a': -1.5025135094805093e-08,
'b': 1e-5,
'c': 1e-5
})
ev = model.eval_diff()
self.assertEqual(-4.99504995, ev['S'])
self.assertEqual(len(ev), 4)
def test_correctness(self):
model = CovidSIRDc()
cor = model.correctness()
self.assertEqual(cor[0], -5.0101099597102863e-09)
update = model.update_abc(update=True)
self.assertIsInstance(update, dict)
cor = model.correctness()
self.assertEqual(cor[0], -5.0101099597102863e-09)
cor = model.correctness(numpy.array([[1., 0., 0., 0.]]))
self.assertLess(abs(cor[0] + 1.50251351e-08), 1e-5)
############################################
# .. _l-sliding-window-sir:
#
# Estimation d'un modèle
# ++++++++++++++++++++++
#
# L'approche sur une fenêtre glissante suggère que le modèle
# n'est pas bon pour approcher les données sur toute une période,
# mais que sur une période courte, le vrai modèle peut être
# approché par un modèle plus simple. On note :math:`W^*(t)`
# les paramètres optimaux au temps *t*, on étudie les courbes
# :math:`t \rightarrow W^*(t)` pour voir comment évolue
# ces paramètres.
model = CovidSIRDc()
print(model.quantity_names)
data = df[['safe', 'infected', 'recovered',
'deaths']].values.astype(numpy.float32)
print(data[:5])
X = data[:-1]
y = data[1:] - data[:-1]
dates = df.index[:-1]
Nlast = 150
X = X[-Nlast:]
y = y[-Nlast:]
dates = dates[-Nlast:]
def test_predict(self):
model = CovidSIRDc()
sim = list(model.iterate(derivatives=True))
self.assertIsInstance(sim, list)
X = model.iterate2array(derivatives=False)
self.assertIsInstance(X, numpy.ndarray)
X, y = model.iterate2array(derivatives=True)
self.assertEqual(X.shape, y.shape)
y2 = model.predict(X)
assert_almost_equal(y / 100, y2 / 100, decimal=6)
with self.assertRaises(TypeError):
model.predict({})
with self.assertRaises(ValueError):
model.predict(numpy.array([4]))
with self.assertRaises(ValueError):
model.predict(numpy.array([[4, 5, 6, 7, 8]]))
X2 = X.copy()
X2[0, 0] -= 50
with self.assertRaises(ValueError):
model.predict(X2)
X2 = X.copy()
X2[:, 0] -= 50
with self.assertRaises(ValueError):
model.predict(X2)
def test_eval_diff(self):
model = CovidSIRDc()
df1 = model.eval_diff()
df2 = model._eval_diff_sympy()
self.assertEqual(df1, df2)
def test_fit(self):
model = CovidSIRDc()
X, y = model.iterate2array(derivatives=True)
with self.assertRaises(TypeError):
model.fit(X, {})
with self.assertRaises(ValueError):
model.fit(X, numpy.array([4]))
with self.assertRaises(ValueError):
model.fit(X, numpy.array([[4, 5, 6, 7, 8]]))
X2 = X.copy()
X2[0, 0] = -5
with self.assertRaises(ValueError):
model.fit(X2, y, learning_rate_init=0.01)
exp = numpy.array(
[model['beta'], model['nu'], model['mu'], model['b']])
model.fit(X, y, verbose=False, max_iter=10, learning_rate_init=0.01)
coef = numpy.array(
[model['beta'], model['nu'], model['mu'], model['b']])
err = numpy.linalg.norm(exp - coef)
self.assertLess(err, 1e-5)
model['nu'] = model['mu'] = model['beta'] = 0.1
buf = io.StringIO()
with redirect_stdout(buf):
model.fit(X, y, verbose=True, max_iter=20)
out = buf.getvalue()
self.assertIn('20/20', out)
coef = numpy.array(
[model['beta'], model['nu'], model['mu'], model['b']])
err = numpy.linalg.norm(exp - coef)
self.assertLess(err, 1)
loss = model.score(X, y)
self.assertGreater(loss, 0)
loss = model.score_l1(X, y)
self.assertGreater(loss, 0)