def setUp(self):
"""
Set up Lotka-Volterra ODE (i.e. two-dim, four parameter) and
multiple (two) evalpts.
"""
# Set Model Parameters
odeparam = np.array([0, 1, 1, 2])
y0, y0_unc = np.ones(2), 0 * np.ones(2)
t0, tmax = 0.0, 1.25
# Set Method Parameters
q = 1
h = 0.1
# Set up and solve ODE
ibm = statespace.IBM(q=q, dim=len(y0))
solver = linsolve.LinearisedODESolver(ibm)
ivp = linode.LotkaVolterra(t0, tmax, odeparam, y0, y0_unc)
tsteps, means, __, rhs_parts, uncerts = solver.solve(ivp, stepsize=h)
self.mean = odesolver.get_trajectory_multidim(means, [0, 1], 0)
# Set up BM and IBM covariance matrices
evalpt = np.array(tsteps[[-1, -10]])
derdat = (tsteps, rhs_parts, 0.)
const, jacob = linearisation.compute_linearisation(
ssm=ibm, initial_value=y0,
derivative_data=derdat, prdct_tsteps=evalpt)
# Compute GP Estimation of filter mean at t=tmax
postmean = const + np.dot(jacob, odeparam)
self.postmean = postmean.reshape((2, 2))
def test_init_wrong_initval_3(self):
"""
Test passes if LotkaVolterra initialisation complains about
wrong number of parameters; 3 instead of 2.
"""
t0, tmax = 0., 1.
params = [0.2, 3.0, 1.0, 2.0]
initval, initval_unc = [1., 2., 3.], 0.1
with self.assertRaises(TypeError):
linode.LotkaVolterra(t0, tmax, params, initval, initval_unc)
def setUp(self):
"""
Set up LotkaVolterra ODE and LinearisedODESolver.
"""
prior = stsp.IBM(q=1, dim=2)
solver = linsolver.LinearisedODESolver(prior, filtertype="kalman")
params = [0.1, 0.2, 0.3, 0.4]
ode = linode.LotkaVolterra(t0=0.0,
tmax=1.2,
params=params,
initval=np.ones(2))
h = 0.1
output = solver.solve(ode, h)
__, __, __, self.rhs_parts, self.uncert = output
])
ipdata = ip.InvProblemData(evalpts, data, ivpvar)
return ipdata
if __name__ == "__main__":
np.random.seed(1)
# Set Model Parameters
initial_value = np.array([20, 20])
initial_time, end_time = 0.0, 5.0
ivpvar = 1e-2
thetatrue = np.array([1.0, 0.1, 0.1, 1.0])
ivp = linode.LotkaVolterra(initial_time,
end_time,
params=thetatrue,
initval=initial_value)
# Set Method Parameters
h_for_data = (end_time - initial_time) / 10000
h = (end_time - initial_time) / 200
solver = linsolver.LinearisedODESolver(statespace.IBM(q=1, dim=2))
ipdata = create_data(solver, ivp, thetatrue, h_for_data, ivpvar)
iplklhd = ip.InvProblemLklhd(ipdata, ivp, solver, h, with_jacob=True)
# Sample from posteriors
niter = 50
init_theta = np.array([0.8, 0.2, 0.05, 1.1])
samples_ham, probs_ham = hamiltonian(niter,
iplklhd,
init_theta,
"""
import numpy as np
from difflikelihoods import linearised_ode as linode
from difflikelihoods import odesolver
from difflikelihoods import statespace
import matplotlib.pyplot as plt
# Solve ODE
stsp = statespace.IBM(q=2, dim=2)
solver = odesolver.ODESolver(ssm=stsp, filtertype="kalman")
t0, tmax = 0.0, 15.0
lotka = linode.LotkaVolterra(
t0=t0,
tmax=tmax,
params=[1.0, 0.01, 0.02, 1.0],
initval=np.array([20.0, 20.0]),
initval_unc=1,
)
h = 0.01
t, m, s = solver.solve(lotka, stepsize=h)
# Extract relevant trajectories
mtraj1 = odesolver.get_trajectory(m, 0, 0)
munc1 = odesolver.get_trajectory(s, 0, 0)
mtraj2 = odesolver.get_trajectory(m, 1, 0)
munc2 = odesolver.get_trajectory(s, 1, 0)
# Plot solution
plt.title("Lotka-Volterra Phase Plane Plot (h=%r)" % h)
plt.plot(mtraj1, mtraj2, color="darkslategray", linewidth=1.5, label="Trajectory")
def setUp(self):
t0, tmax = 0., 1.
params = [2., 1., 2., 1.]
initval, initval_unc = [1., 1.], 0.1
self.lotka = linode.LotkaVolterra(t0, tmax, params, initval,
initval_unc)