def to_carmapack_params(self, p):
p = self.to_params(p)
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
sigma = par.bounded_values(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
pc = np.zeros(self.nparams)
pc[0] = sigma
pc[1] = nu * nu # carma_pack wants variance scaling
pc[2] = mu
assert self.p >= 1, 'Must have at least one AR root'
pc[3:3 + self.p] = self._roots_to_quad(
par.stable_polynomial_roots(p['ar_roots_p'], self.root_min,
self.root_max))
if self.q >= 1:
pc[3 + self.p:] = self._roots_to_quad(
par.stable_polynomial_roots(p['ma_roots_p'], self.root_min,
self.root_max))
return pc
def kep_deparameterize(self, kps):
dkps = np.zeros_like(kps)
dkps[:,0] = par.bounded_values(kps[:,0], low=0, high=0.1) # bounded(K, 0, 100 m/s) => K
dkps[:,1] = par.bounded_values(kps[:,1], low=0, high=self.T) # bounded(P, 0, T) => P
dkps[:,2] = par.bounded_values(kps[:,2], low=0, high=1) # bounded(e, 0, 1) => e
dkps[:,3] = par.bounded_values(kps[:,3], low=0, high=2*np.pi) # bounded(omega, 0, 2*pi) => omega
dkps[:,4] = par.bounded_values(kps[:,4], low=0, high=1) # bounded(chi, 0, 1) => chi
return dkps
def log_prior(self, p):
p = self.to_params(p)
lp = 0.0
# mu
lp += par.bounded_log_jacobian(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
# sigma
lp += par.bounded_log_jacobian(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
sigma = par.bounded_values(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
lp -= np.log(sigma)
# nu
lp += par.bounded_log_jacobian(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
lp -= np.log(nu)
# ar roots
lp += par.stable_polynomial_log_jacobian(p['ar_roots_p'],
self.root_min, self.root_max)
roots = par.stable_polynomial_roots(p['ar_roots_p'], self.root_min,
self.root_max)
lp -= np.sum(np.log(np.abs(roots)))
if self.q >= 1:
lp += par.stable_polynomial_log_jacobian(p['ma_roots_p'],
self.root_min,
self.root_max)
roots = par.stable_polynomial_roots(p['ma_roots_p'], self.root_min,
self.root_max)
lp -= np.sum(np.log(np.abs(roots)))
if np.isnan(lp):
lp = -np.inf
return lp
def deparameterize(self, p):
p = self.to_params(p)
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
sigma = par.bounded_values(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
ar_roots = self.ar_roots(p)
arr = []
for i in range(0, ar_roots.shape[0] - 1, 2):
ar1 = ar_roots[i]
ar2 = ar_roots[i + 1]
if np.imag(ar1) > 0:
arr.append(np.real(ar1))
arr.append(np.abs(np.imag(ar1)))
else:
arr.append(np.real(ar1))
arr.append(np.real(ar2))
if ar_roots.shape[0] % 2 == 1:
arr.append(np.real(ar_roots[-1]))
arr = np.array(arr)
if self.q > 0:
ma_roots = self.ma_roots(p)
mar = []
for i in range(0, ma_roots.shape[0] - 1, 2):
ma1 = ma_roots[i]
ma2 = ma_roots[i + 1]
if np.imag(ma1) > 0:
mar.append(np.real(ma1))
mar.append(np.abs(np.imag(ma1)))
else:
mar.append(np.real(ma1))
mar.append(np.real(ma2))
if ma_roots.shape[0] % 2 == 1:
mar.append(np.real(ma_roots[-1]))
mar = np.array(mar)
return np.concatenate((mu, sigma, nu, arr, mar))
else:
return np.concatenate((mu, sigma, nu, arr))
def kep_deparameterize(self, kps):
dkps = np.zeros_like(kps)
dkps[:,
0] = par.bounded_values(kps[:, 0], low=0,
high=0.1) # bounded(K, 0, 100 m/s) => K
dkps[:, 1] = par.bounded_values(kps[:, 1], low=0,
high=self.T) # bounded(P, 0, T) => P
dkps[:, 2] = par.bounded_values(kps[:, 2], low=0,
high=1) # bounded(e, 0, 1) => e
dkps[:,
3] = par.bounded_values(kps[:, 3], low=0, high=2 *
np.pi) # bounded(omega, 0, 2*pi) => omega
dkps[:, 4] = par.bounded_values(kps[:, 4], low=0,
high=1) # bounded(chi, 0, 1) => chi
return dkps
def white_noise(self, p, bw):
p = self.to_params(p)
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
return self.wn_var * nu * nu / bw
def simulate(self, p, ts, dys=None):
p = self.to_params(p)
kfilter = self._make_kalman_filter(p)
vtime = cm.vecD()
vtime.extend(ts)
ysim = np.asarray(kfilter.Simulate(vtime))
if dys is not None:
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
ysim = ysim + np.random.randn(ysim.shape[0]) * dys * nu
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
return ysim + mu
def residuals(self, p):
p = self.to_params(p)
kfilter = self._make_kalman_filter(p)
kmean = np.asarray(kfilter.GetMean())
kvar = np.asarray(kfilter.GetVar())
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
return (self.y - mu - kmean), kvar
def _make_kalman_filter(self, p):
p = self.to_params(p)
ar_roots = self.ar_roots(p)
ma_coefs = self.ma_poly(p)
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
nu = par.bounded_values(p['logit_nu'],
low=self.nu_min,
high=self.nu_max)
s = par.bounded_values(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
sigma = s / np.sqrt(cm.carma_variance(1.0, ar_roots, ma_coefs))
sigmasq = sigma * sigma
sigmasq = float(sigmasq)
tv = cm.vecD()
tv.extend(self.t)
yv = cm.vecD()
yv.extend(self.y - mu)
dyv = cm.vecD()
dyv.extend(self.dy * nu)
arv = cm.vecC()
arv.extend(ar_roots)
mav = cm.vecD()
mav.extend(ma_coefs)
kfilter = cm.KalmanFilterp(tv, yv, dyv, sigmasq, arv, mav)
kfilter.Filter()
return kfilter
def predict(self, p, ts):
p = self.to_params(p)
kfilter = self._make_kalman_filter(p)
ypred = []
ypred_var = []
for t in ts:
yp = kfilter.Predict(t)
ypred.append(yp.first)
ypred_var.append(yp.second)
mu = par.bounded_values(p['logit_mu'],
low=self.mu_min,
high=self.mu_max)
return np.array(ypred) + mu, np.array(ypred_var)
def power_spectrum(self, fs, p):
p = self.to_params(p)
ar_roots = self.ar_roots(p)
ma_roots = self.ma_roots(p)
ar_coefs = np.real(np.poly(ar_roots))
ma_coefs = np.real(np.poly(ma_roots))
ma_coefs /= ma_coefs[-1]
ma_coefs = ma_coefs[::-1]
s = par.bounded_values(p['logit_sigma'],
low=self.sigma_min,
high=self.sigma_max)
sigma = s / np.sqrt(cm.carma_variance(1.0, ar_roots, ma_coefs))
return cm.power_spectrum(fs, sigma, ar_coefs, ma_coefs)
