def _I_hx_0_sin(model, n, t):
"""Compute the :math:`I_{0,n:\\sin}`, :math:`n>M`, integral."""
omega = 2 * B.pi * (n - model.m_max) / (model.b - model.a)
t_less_a = t - model.a
return (
model.alpha_t**2
/ (4 * model.alpha**2 + omega**2)
* (
omega * (B.exp(-2 * model.alpha * t_less_a) - B.cos(omega * t_less_a))
+ 2 * model.alpha * B.sin(omega * t_less_a)
)
)
def k_h(self):
"""Get the kernel function of the filter.
Returns:
:class:`mlkernels.Kernel`: Kernel for :math:`h`.
"""
# Convert `self.gamma` to a regular length scale.
gamma_scale = B.sqrt(1 / (2 * self.gamma))
k_h = EQ().stretch(gamma_scale) # Kernel of filter before window
k_h *= lambda t: B.exp(-self.alpha * t**2) # Window
if self.causal:
k_h *= lambda t: B.cast(self.dtype, t >= 0) # Causality constraint
return k_h
def compute_K_u(model):
"""Covariance matrix of inducing variables :math:`u` associated with
:math:`h`.
Args:
model (:class:`.gprv.GPRV`): Model.
Returns:
tensor: :math:`K_u`.
"""
return Dense(
(model.gamma_t**2 / (2 * model.gamma))
* B.exp(-model.gamma * B.abs(model.t_u[:, None] - model.t_u[None, :]))
)
def _integral_luk_g_M(model, l, u, k):
"""Internal function :math:`I(l,u,k)` for :math:`k>M`. Assumes that :math:`a<l,u<b`.
Note:
This function gives :math:`-I(l,u,k)`, i.e. *minus* the integral in the paper!
"""
ag = model.alpha - model.gamma
om = 2 * B.pi * (k - model.m_max) / (model.b - model.a)
return (-1 / (ag**2 + om**2)) * (
(-ag * B.sin(om * (u - model.a)) + om * B.cos(om * (u - model.a)))
- (
B.exp(ag * (l - u))
* (-ag * B.sin(om * (l - model.a)) + om * B.cos(om * (l - model.a)))
)
)
def _integrate_half1(self, name, **var_map):
if self.poly.highest_power(name) != 2:
raise RuntimeError(f'Dependency on "{name}" must be quadratic.')
a = self.poly.collect_for(Factor(name, 2))
b = self.poly.collect_for(Factor(name, 1))
c = self.poly.reject(name)
a = a.eval(**var_map)
b = b.eval(**var_map)
c = c.eval(**var_map)
return (0.5 * self.const * safe_sqrt(-B.pi / a) *
B.exp(-0.25 * b**2 / a + c) *
(1 - B.erf(0.5 * b / safe_sqrt(-a))))
def compute_i_hx(model, t1=None, t2=None):
"""Compute the :math:`I_{hx}` integral.
Args:
model (:class:`.gprv.GPRV`): Model.
t1 (tensor, optional): First time input. Defaults to zero.
t2 (tensor, optional): Second time input. Defaults to zero.
Returns:
tensor: Value of :math:`I_{hx}` for all `t1` and `t2`.
"""
if t1 is None:
t1 = B.zero(model.dtype)
if t2 is None:
t2 = B.zero(model.dtype)
return model.alpha_t**2 / 2 / model.alpha * B.exp(-model.lam * B.abs(t1 - t2))
def positive(self, init=None, shape=None, dtype=None, name=None):
# If nothing is specific, generate a scalar.
if init is None and shape is None:
shape = ()
def generate_init(shape, dtype):
return B.rand(dtype, *shape)
return self._get_var(
transform=lambda x: B.exp(x),
inverse_transform=lambda x: B.log(x),
init=init,
generate_init=generate_init,
shape=shape,
shape_latent=shape,
dtype=dtype,
name=name,
)
def compute_I_ux(model, t1=None, t2=None):
"""Compute the :math:`I_{ux}` integral.
Args:
model (:class:`.gprv.GPRV`): Model.
t1 (tensor, optional): First time input. Defaults to zero.
t2 (tensor, optional): Second time input. Defaults to zero.
Returns:
tensor: Value of :math:`I_{ux}` for all `t1`, `t2`.
"""
if t1 is None:
t1 = B.zeros(model.dtype, 1)
squeeze_t1 = True
else:
squeeze_t1 = False
if t2 is None:
t2 = B.zeros(model.dtype, 1)
squeeze_t2 = True
else:
squeeze_t2 = False
t1 = t1[:, None, None, None]
t2 = t2[None, :, None, None]
t_u_1 = model.t_u[None, None, :, None]
t_u_2 = model.t_u[None, None, None, :]
ga = model.gamma - model.alpha
result = (
model.alpha_t**2
* model.gamma_t**2
* B.exp(-model.gamma * (t_u_1 + t_u_2) + ga * (t1 + t2))
* integral_abcd_lu(-t1, t_u_2 - t1, -t2, t_u_1 - t2, ga, model.lam)
)
if squeeze_t1 and squeeze_t2:
return result[0, 0, :, :]
elif squeeze_t1:
return result[0, :, :, :]
elif squeeze_t2:
return result[:, 0, :, :]
else:
return result
def f1(x):
dists2 = (x - B.transpose(x))**2
K = B.exp(-0.5 * dists2)
K = K + B.epsilon * B.eye(t, n)
L = B.cholesky(K)
return B.matmul(L, B.ones(t, n, m))
def test_inducing_points_extent_gprv():
model = RGPCM(window=2, scale=1, n_u=10, t=(0, 10))
t_u_max = max(model.t_u)
approx(B.exp(-model.alpha * t_u_max), B.exp(-B.pi))
def test_inducing_points_extent_gpcm(Model):
model = Model(window=2, scale=1, n_u=10, t=(0, 10))
approx(B.exp(-model.alpha * max(model.t_u)**2), B.exp(-B.pi))
def _integral_lu0(model, l, u):
"""Compute :math:`I(l,u,k)` for :math:`k=0`."""
ag = model.alpha - model.gamma
return 1 / ag * (1 - B.exp(ag * (l - u)))
def transform(x):
return lower + (upper - lower) / (1 + B.exp(x))
def transform(x):
log_diag = x[:side]
chol = B.vec_to_tril(x[side:], offset=-1) + B.diag(B.exp(log_diag))
return B.matmul(chol, chol, tr_b=True)
