def test_get_filtered_val_all_xi(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
Test df with all xi
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
Yt_filtered, Yt_filtered_cov, xi_t, P_t = kf.get_filtered_val()
np.testing.assert_array_equal(xi_t[2], kf.xi_t[2][0])
np.testing.assert_array_equal(P_t[2], np.nan * np.ones(P_t[2].shape))
np.testing.assert_array_equal(P_t[3], kf.P_star_t[3][0])
def test_get_smoothed_val_all_xi(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
Test df with all xi
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.fit(kf)
y_t_T, yP_t_T, xi_T, P_T = ks.get_smoothed_val()
np.testing.assert_array_equal(xi_T[2], ks.xi_t_T[2])
np.testing.assert_array_equal(P_T[2], ks.P_t_T[2])
np.testing.assert_array_equal(P_T[3], ks.P_t_T[3])
Mt = ft_ll_mvar_diffuse(theta_ll_mvar_diffuse, 4)
Rt = Mt['Rt'][0]
Dt = Mt['Dt'][0]
Ht = Mt['Ht'][0]
# Test smoothed y
R2_0 = np.array([[0.5 - 0.4 / 0.6 * 0.4]])
B0 = 0.4 / 0.6
delta_H0 = Ht[0:1] - B0 * Ht[1:]
eps0 = B0 * (Yt_mvar_diffuse_missing[0][1] - Dt[1:].dot(ks.Xt[0]) -
Ht[1:].dot(ks.xi_t_T[0]))
y0 = Ht[0:1].dot(ks.xi_t_T[0]) + Dt[0:1].dot(ks.Xt[0]) + eps0
yP_0 = (delta_H0.dot(ks.P_t_T[0]).dot(delta_H0.T) + R2_0).item()
R2_2 = np.array([[0.6 - 0.4 / 0.5 * 0.4]])
B2 = 0.4 / 0.5
delta_H2 = Ht[1] - B2 * Ht[0]
eps2 = B2 * (Yt_mvar_diffuse_missing[2][0] - Dt[:1].dot(ks.Xt[2]) -
Ht[:1].dot(ks.xi_t_T[2]))
y2 = Ht[1:].dot(ks.xi_t_T[2]) + Dt[1:].dot(ks.Xt[2]) + eps2
yP_2 = (delta_H2.dot(ks.P_t_T[2]).dot(delta_H2.T) + R2_2).item()
expected_y_t_T = [
np.array([[y0], [2]]),
Ht.dot(ks.xi_t_T[1] + Dt.dot(ks.Xt[1])),
np.array([[2.5], [y2]]),
np.array([[3], [5]])
]
expected_Pcov_T = [
np.array([[yP_0, 0], [0, 0]]),
ks.Ht[1].dot(ks.P_t_T[1]).dot(ks.Ht[1].T) + ks.Rt[1],
np.array([[0, 0], [0, yP_2]]),
np.zeros([2, 2])
]
for t in range(4):
np.testing.assert_array_almost_equal(yP_t_T[t], expected_Pcov_T[t])
np.testing.assert_array_almost_equal(y_t_T[t], expected_y_t_T[t])
def test_init_attr_smoother_not_for_smoother(ft_rw_1, theta_rw, Yt_1d, Xt_1d):
"""
Test error message Kalman filter not for smoother
"""
kf = Filter(ft_rw_1, Yt_1d, Xt_1d, for_smoother=False)
kf.fit(theta_rw)
ks = Smoother()
with pytest.raises(TypeError) as error:
ks.init_attr_smoother(kf)
msg = str(error.value)
e_msg = 'The Kalman filter object is not for smoothers'
assert msg == e_msg
def test_joseph_form(ft_ar1, theta_ar1, Yt_1d):
"""
Test normal run
"""
kf = Filter(ft_ar1, Yt_1d, for_smoother=True)
L = np.array([[2, 3], [4, 5]])
P = np.array([[3, 4], [4, 5]])
KRK = np.ones([2, 2])
result = kf._joseph_form(L, P, KRK=KRK)
expected_result = np.array([[106, 188], [188, 334]])
np.testing.assert_array_equal(result, expected_result)
def test_init_attr_smoother_diffuse(ft_ll_mvar_diffuse, theta_ll_mvar_diffuse,
Yt_mvar_diffuse_missing):
"""
Test initialization for diffuse smoother
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.init_attr_smoother(kf)
e_r1 = np.zeros([2, 1])
e_N1 = np.zeros([2, 2])
np.testing.assert_array_equal(e_r1, ks.r1_t[ks.t_q - 1])
np.testing.assert_array_equal(e_N1, ks.N1_t[ks.t_q - 1])
assert ks.t_q == 3
def test_get_smoothed_y_selected_xi(ft_ll_mvar_diffuse,
Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
Test df with selected xi
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.fit(kf)
_, _, xi_T, P_T = ks.get_smoothed_val(xi_col=[1])
np.testing.assert_array_equal(xi_T[2], ks.xi_t_T[2][[1]])
np.testing.assert_array_equal(P_T[2], ks.P_t_T[2][[1]][:, [1]])
def test_sequential_update_diffuse_missing(ft_rw_1_diffuse, theta_rw,
Yt_1d_missing, Xt_1d):
"""
Test first missing
"""
t = 0
kf = Filter(ft_rw_1_diffuse, Yt_1d_missing, Xt_1d, for_smoother=True)
kf.init_attr(theta_rw)
for t_ in range(t + 1):
kf._sequential_update_diffuse(t_)
e_P_inf_t1_0 = np.array([[1]])
e_xi_t1_0 = np.array([[0]])
np.testing.assert_array_almost_equal(e_P_inf_t1_0, kf.P_inf_t[t + 1][0])
np.testing.assert_array_almost_equal(e_xi_t1_0, kf.xi_t[t + 1][0])
def test_sequential_update_diffuse_ll_equivalent(ft_ll_mvar_diffuse,
ft_ll_mvar_1d,
Yt_mvar_diffuse_missing,
Yt_mvar_1d,
theta_ll_mvar_diffuse):
"""
Test in the case of misisng values such that at most 1 measurement present
at time t, whether we get same result as 1d case
"""
kf_mvar = Filter(ft_ll_mvar_diffuse,
Yt_mvar_diffuse_missing,
for_smoother=True)
kf_mvar.fit(theta_ll_mvar_diffuse)
kf_1d = Filter(ft_ll_mvar_1d, Yt_mvar_1d, for_smoother=True)
kf_1d.fit(theta_ll_mvar_diffuse)
for t_ in range(kf_mvar.T - 1):
np.testing.assert_array_almost_equal(kf_1d.P_star_t[t_][0],
kf_mvar.P_star_t[t_][0])
np.testing.assert_array_almost_equal(kf_1d.P_inf_t[t_][0],
kf_mvar.P_inf_t[t_][0])
np.testing.assert_array_almost_equal(kf_1d.xi_t[t_][0],
kf_mvar.xi_t[t_][0])
def test_over_ride_error_input(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
Raises exception when init_state wrong input
"""
init_val = {
'P_star_t': np.zeros([2]),
'xi_t': 100 * np.ones([2, 1]),
'q': 0
}
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
with pytest.raises(ValueError) as error:
kf.fit(theta_ll_mvar_diffuse, init_state=init_val)
expected_result = 'User-specified P_star_t does not have 2 dimensions'
result = str(error.value)
assert expected_result == result
def test_get_filtered_state_T(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
t = kf.T
result = kf.get_filtered_state(t)
expected_result = {
'P_star_t': kf.P_T1,
'P_inf_t': np.zeros([2, 2]),
'xi_t': kf.xi_T1,
'q': 0
}
for i in ['P_star_t', 'P_inf_t', 'xi_t']:
np.testing.assert_array_equal(result[i], expected_result[i])
assert result['q'] == expected_result['q']
def test_sequential_update_diffuse(ft_rw_1_diffuse, theta_rw, Yt_1d_missing,
Xt_1d):
"""
Test normal run
"""
t = 1
kf = Filter(ft_rw_1_diffuse, Yt_1d_missing, Xt_1d, for_smoother=True)
kf.init_attr(theta_rw)
for t_ in range(t + 1):
kf._sequential_update_diffuse(t_)
e_P_inf_t1_0 = np.array([[0]])
e_P_star_t1_0 = kf.Rt[0] + kf.Qt[0]
e_xi_t1_0 = kf.Yt[1]
np.testing.assert_array_almost_equal(e_P_inf_t1_0, kf.P_inf_t[t + 1][0])
np.testing.assert_array_almost_equal(e_xi_t1_0, kf.xi_t[t + 1][0])
np.testing.assert_array_almost_equal(e_P_star_t1_0, kf.P_star_t[t + 1][0])
def test_init_attr_smoother(ft_rw_1, theta_rw, Yt_1d, Xt_1d):
"""
Test normal run
"""
kf = Filter(ft_rw_1, Yt_1d, Xt_1d, for_smoother=True)
kf.fit(theta_rw)
ks = Smoother()
ks.init_attr_smoother(kf)
e_r0 = np.zeros([1, 1])
e_N0 = np.zeros([1, 1])
r0 = ks.r0_t[kf.T - 1]
N0 = ks.N0_t[kf.T - 1]
np.testing.assert_array_equal(e_r0, r0)
np.testing.assert_array_equal(e_N0, N0)
assert ks.r1_t.shape[0] == 0
def test_sequential_update_diffuse_ll_Upsilon_inf0(ft_ll_mvar_diffuse,
theta_ll_mvar_diffuse,
Yt_mvar_diffuse):
"""
For ll model, only measurements across time can reduce rank of P_inf_t
"""
t = 1
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse, for_smoother=True)
kf.init_attr(theta_ll_mvar_diffuse)
for t_ in range(t):
kf._sequential_update_diffuse(t_)
# Test period 0 result
e_P_inf_t1_0 = np.ones([2, 2])
expected_q = 1
np.testing.assert_array_almost_equal(e_P_inf_t1_0, kf.P_inf_t[1][0])
assert expected_q == kf.q
# Test update when Upsilon_inf = 0
index = 2
ob = index - 1
t = 0
l_t, _, _ = linalg.ldl(kf.Rt[t])
l_inv, _ = linalg.lapack.dtrtri(l_t, lower=True)
R_t = l_inv.dot(kf.Rt[t])
H_t = (l_inv.dot(kf.Ht[t]))[ob:index]
D_t = (l_inv.dot(kf.Dt[t]))[ob:index]
Upsilon = H_t.dot(kf.P_star_t[t][ob]).dot(H_t.T) + R_t[ob][ob]
K = kf.P_star_t[t][ob].dot(H_t.T) / Upsilon
v = l_inv.dot(kf.Yt[t])[ob] - H_t.dot(kf.xi_t[t][ob]) - D_t.dot(kf.Xt[t])
expected_xi_t_11 = kf.xi_t[t][ob] + K * v
expected_P_t_11 = kf.P_star_t[t][ob] - kf.P_star_t[t][ob].dot(
(K.dot(H_t)).T)
expected_P_t1_0 = kf.Ft[t].dot(expected_P_t_11).dot(kf.Ft[t].T) + kf.Qt[t]
expected_xi_t1_0 = kf.Ft[t].dot(expected_xi_t_11) + \
kf.Bt[t].dot(kf.Xt[t])
np.testing.assert_array_almost_equal(expected_xi_t_11,
kf.xi_t[t][kf.n_t[t]])
np.testing.assert_array_almost_equal(expected_P_t_11,
kf.P_star_t[t][kf.n_t[t]])
np.testing.assert_array_almost_equal(expected_P_t1_0,
kf.P_star_t[t + 1][0])
np.testing.assert_array_almost_equal(expected_xi_t1_0, kf.xi_t[t + 1][0])
def test_sequential_update_diffuse_ll_1d(ft_ll_1d_diffuse, theta_ll_1d_diffuse,
Yt_1d_full):
"""
Test local linear models from chapter 5 of Koopman and Durbin (2012)
"""
t = 3
kf = Filter(ft_ll_1d_diffuse, Yt_1d_full, for_smoother=True)
kf.init_attr(theta_ll_1d_diffuse)
for t_ in range(t):
kf._sequential_update_diffuse(t_)
# Test period 0 result
q1 = theta_ll_1d_diffuse[0] / theta_ll_1d_diffuse[2]
q2 = theta_ll_1d_diffuse[1] / theta_ll_1d_diffuse[2]
e_P_inf_t1_0 = np.ones([2, 2])
e_P_star_t1_0 = np.array([[1 + q1, 0], [0, q2]]) * theta_ll_1d_diffuse[2]
e_xi_t1_0 = np.array([[Yt_1d_full[0][0]], [0]])
np.testing.assert_array_almost_equal(e_P_inf_t1_0, kf.P_inf_t[1][0])
np.testing.assert_array_almost_equal(e_xi_t1_0, kf.xi_t[1][0])
np.testing.assert_array_almost_equal(e_P_star_t1_0, kf.P_star_t[1][0])
# Test period 1 result
e_P_inf_t1_0 = np.zeros([2, 2])
e_P_star_t1_0 = np.array([[5 + 2 * q1 + q2, 3 + q1 + q2],
[3 + q1 + q2, 2 + q1 + 2 * q2]]) * \
theta_ll_1d_diffuse[2]
y2 = Yt_1d_full[1][0][0]
y1 = Yt_1d_full[0][0][0]
e_xi_t1_0 = np.array([[2 * y2 - y1], [y2 - y1]])
np.testing.assert_array_almost_equal(e_P_inf_t1_0, kf.P_inf_t[2][0])
np.testing.assert_array_almost_equal(e_xi_t1_0, kf.xi_t[2][0])
np.testing.assert_array_almost_equal(e_P_star_t1_0, kf.P_star_t[2][0])
# Test period 2 result, should return same result as _sequential_update()
P_inf_t1_0 = kf.P_inf_t[3][0].copy()
P_star_t1_0 = kf.P_star_t[3][0].copy()
xi_t1_0 = kf.xi_t[3][0].copy()
kf._sequential_update(2)
np.testing.assert_array_almost_equal(P_inf_t1_0, np.zeros([2, 2]))
np.testing.assert_array_almost_equal(xi_t1_0, kf.xi_t[3][0])
np.testing.assert_array_almost_equal(P_star_t1_0, kf.P_star_t[3][0])
def test_get_filtered_state_t(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
get values at t < self.T
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
t = kf.T - 1
result = kf.get_filtered_state(t)
expected_result = {
'P_star_t': kf.P_star_t[t][0],
'P_inf_t': kf.P_inf_t[t][0],
'xi_t': kf.xi_t[t][0],
'q': 0
}
for i in ['P_star_t', 'P_inf_t', 'xi_t']:
np.testing.assert_array_equal(result[i], expected_result[i])
assert result['q'] == expected_result['q']
def test_E_delta2(ft_ll_mvar_diffuse, theta_ll_mvar_diffuse,
Yt_mvar_diffuse_smooth):
"""
Test normal run
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_smooth, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.fit(kf)
t = 2
theta_test = [i + 0.1 for i in theta_ll_mvar_diffuse]
Mt = ft_ll_mvar_diffuse(theta_test, ks.T)
delta2 = ks._E_delta2(Mt, t)
nt = ks.xi_t_T[t] - Mt['Ft'][t-1].dot(ks.xi_t_T[t-1]) - \
Mt['Bt'][t-1].dot(ks.Xt[t-1])
e_delta2 = nt.dot(nt.T) + ks.P_t_T[t] + Mt['Ft'][t - 1].dot(
ks.P_t_T[t - 1]).dot(Mt['Ft'][t - 1].T) - Mt['Ft'][t - 1].dot(
ks.Pcov_t_t1[t - 1]) - (ks.Pcov_t_t1[t - 1].T).dot(
Mt['Ft'][t - 1].T)
np.testing.assert_array_almost_equal(e_delta2, delta2)
def test_sequential_update_mvar_all_missing(ft_ar2_mvar_kw, theta_ar2_mvar,
Yt_ar2_mvar, Xt_ar2_mvar):
"""
Test normal run in multi-variate case missing all measurements
"""
t = 2
kf = Filter(ft_ar2_mvar_kw, Yt_ar2_mvar, Xt_ar2_mvar, for_smoother=True)
kf.init_attr(theta_ar2_mvar)
for t_ in range(t + 1):
kf._sequential_update(t_)
Mt = kf.ft(kf.theta, kf.T, x_0=Xt_ar2_mvar[0])
Bt = Mt['Bt'][t]
Ft = Mt['Ft'][t]
Qt = Mt['Qt'][t]
expected_xi_t1_0 = Ft.dot(kf.xi_t[t][0]) + Bt.dot(kf.Xt[t])
P_t_0 = kf.P_star_t[t][0]
P_t_t = P_t_0
expected_P_t1_0 = Ft.dot(P_t_t).dot(Ft.T) + Qt
np.testing.assert_array_almost_equal(expected_P_t1_0,
kf.P_star_t[t + 1][0])
np.testing.assert_array_almost_equal(expected_xi_t1_0, kf.xi_t[t + 1][0])
def test_get_LL_explosive_root(f_arma32):
"""
Test how to handle explosive root in Filter
"""
# Initialize the model
x = 1 # used to calculate stationary mean
model = BCM()
model.set_f(f_arma32)
theta_intend = np.array([0.1, 0.2, 0.25])
theta_test = np.array([0.59358299, 0.91708496, 0.54634604])
T = 250
my_ft = lambda theta, T, **kwargs: ft(theta, f_arma32, T, **kwargs)
x_col = ['const']
Xt = pd.DataFrame({x_col[0]: x * np.ones(T)})
# Build simulated data
df, y_col, xi_col = model.simulated_data(input_theta=theta_intend, Xt=Xt)
Xt = df_to_tensor(df, x_col)
Yt = df_to_tensor(df, y_col)
kf = Filter(my_ft, Yt, Xt)
kf.fit(theta_test)
result = kf.get_LL()
assert not np.isnan(result)
def test_sequential_update_uni(ft_rw_1, theta_rw, Yt_1d, Xt_1d):
"""
Test normal run in univariate case
"""
t = 0
index = 1
ob = index - 1
kf = Filter(ft_rw_1, Yt_1d, Xt_1d, for_smoother=True)
kf.init_attr(theta_rw)
kf._sequential_update(t)
K = kf.P_star_t[t][ob] / (kf.P_star_t[t][ob] + kf.Rt[t][ob][ob])
v = kf.Yt[t][ob] - kf.xi_t[t][ob] - kf.Dt[t][ob].dot(kf.Xt[t])
expected_xi_t_11 = kf.xi_t[t][ob] + K * v
expected_P_t_11 = kf.P_star_t[t][ob].dot(
kf.Rt[t][ob][ob]) / (kf.P_star_t[t][ob] + kf.Rt[t][ob][ob])
expected_P_t1_0 = kf.Ft[t].dot(expected_P_t_11).dot(kf.Ft[t]) + kf.Qt[t]
expected_xi_t1_0 = kf.Ft[t].dot(expected_xi_t_11) + \
kf.Bt[t].dot(kf.Xt[t])
np.testing.assert_array_almost_equal(expected_xi_t_11, kf.xi_t[t][1])
np.testing.assert_array_almost_equal(expected_P_t_11, kf.P_star_t[t][1])
np.testing.assert_array_almost_equal(expected_P_t1_0,
kf.P_star_t[t + 1][0])
np.testing.assert_array_almost_equal(expected_xi_t1_0, kf.xi_t[t + 1][0])
def test_sequential_update_uni_missing(ft_rw_1, theta_rw, Yt_1d, Xt_1d):
"""
Test run in univariate case with missing y
"""
t = 1
index = 1
ob = index - 1
kf = Filter(ft_rw_1, Yt_1d, Xt_1d, for_smoother=True)
kf.init_attr(theta_rw)
for t_ in range(t + 1):
kf._sequential_update(t_)
K = kf.P_star_t[t][ob] / (kf.P_star_t[t][ob] + kf.Rt[t][ob][ob])
v = kf.Yt[t][ob] - kf.xi_t[t][ob] - kf.Dt[t][ob].dot(kf.Xt[t])
expected_xi_t_11 = np.array([[np.nan]])
expected_P_t_11 = np.zeros((1, 1)) * np.nan
expected_P_t1_0 = kf.Ft[t].dot(kf.P_star_t[t][0]).dot(kf.Ft[t]) + kf.Qt[t]
expected_xi_t1_0 = kf.Ft[t].dot(kf.xi_t[t][0]) + \
kf.Bt[t].dot(kf.Xt[t])
np.testing.assert_array_equal(expected_xi_t_11, kf.xi_t[t][1])
np.testing.assert_array_equal(expected_P_t_11, kf.P_star_t[t][1])
np.testing.assert_array_almost_equal(expected_P_t1_0,
kf.P_star_t[t + 1][0])
np.testing.assert_array_almost_equal(expected_xi_t1_0, kf.xi_t[t + 1][0])
def test_over_ride(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing,
theta_ll_mvar_diffuse):
"""
Force a diffuse kalman filter to become regular filter
"""
init_val = {
'P_star_t': np.zeros([2, 2]),
'xi_t': 100 * np.ones([2, 1]),
'q': 0
}
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_missing, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse, init_state=init_val)
t = 0
result = kf.get_filtered_state(t)
expected_result = {
'P_star_t': np.zeros([2, 2]),
'P_inf_t': np.zeros([2, 2]),
'xi_t': 100 * np.ones([2, 1]),
'q': 0
}
for i in ['P_star_t', 'P_inf_t', 'xi_t']:
np.testing.assert_array_equal(result[i], expected_result[i])
assert result['q'] == expected_result['q']
def test_sequential_smooth_diffuse_missing(ft_ll_mvar_diffuse,
theta_ll_mvar_diffuse,
Yt_mvar_diffuse_smooth):
"""
Test cases with diffuse initial conditions. I test period 1
in a seperate test, as the sequential smoother uses a different
system of r and N.
"""
kf = Filter(ft_ll_mvar_diffuse, Yt_mvar_diffuse_smooth, for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.fit(kf)
# Test period 2
t = 1
Ft = ks.Ft[t]
n_t = ks.n_t[t]
xi_t = ks.xi_t[t][0]
P_inf_t = ks.P_inf_t[t][0]
P_star_t = ks.P_star_t[t][0]
r0_t = ks.r0_t[t + 1]
r1_t = ks.r1_t[t + 1]
N0_t = ks.N0_t[t + 1]
N1_t = ks.N1_t[t + 1]
N2_t = ks.N2_t[t + 1]
r0_1t = (Ft.T).dot(r0_t)
r1_1t = (Ft.T).dot(r1_t)
e_xi_T = xi_t + P_star_t.dot(r0_1t) + P_inf_t.dot(r1_1t)
N0_1t = (Ft.T).dot(N0_t).dot(Ft)
N1_1t = (Ft.T).dot(N1_t).dot(Ft)
N2_1t = (Ft.T).dot(N2_t).dot(Ft)
e_P_T = P_star_t - P_star_t.dot(N0_1t).dot(P_star_t) - P_star_t.dot(
N1_1t).dot(P_inf_t) - P_inf_t.dot(N1_1t).dot(P_star_t) - \
P_inf_t.dot(N2_1t).dot(P_inf_t)
e_P_cov_t_t1 = (P_star_t.dot(Ft.T) + P_inf_t.dot(Ft.T)).dot(
ks.I - N1_t.dot(ks.P_inf_t[t + 1][0]) -
N0_t.dot(ks.P_star_t[t + 1][0])) - P_inf_t.dot(Ft.T).dot(
N2_t.dot(ks.P_inf_t[t + 1][0]) + N1_t.dot(ks.P_star_t[t + 1][0]))
np.testing.assert_array_almost_equal(e_xi_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_P_cov_t_t1, ks.Pcov_t_t1[t])
np.testing.assert_array_almost_equal(r0_1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(r1_1t, ks.r1_t[t])
np.testing.assert_array_almost_equal(N0_1t, ks.N0_t[t])
np.testing.assert_array_almost_equal(N1_1t, ks.N1_t[t])
np.testing.assert_array_almost_equal(N2_1t, ks.N2_t[t])
# Test period 3
t = 2
Ft = ks.Ft[t]
n_t = ks.n_t[t]
xi_t = ks.xi_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Ht = ks.Ht[t][:n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
P_inf_t = ks.P_inf_t[t][0]
P_star_t = ks.P_star_t[t][0]
Upsilon_inf_t = Ht.dot(P_inf_t).dot(Ht.T)
Upsilon_star_t = Ht.dot(P_star_t).dot(Ht.T) + Rt
Upsilon_1 = linalg.pinv(Upsilon_inf_t)
Upsilon_2 = -Upsilon_1.dot(Upsilon_star_t).dot(Upsilon_1)
K0 = P_inf_t.dot(Ht.T).dot(Upsilon_1)
K1 = P_star_t.dot(Ht.T).dot(Upsilon_1) + \
P_inf_t.dot(Ht.T).dot(Upsilon_2)
L0 = Ft.dot(ks.I - K0.dot(Ht))
L1 = -Ft.dot(K1.dot(Ht))
r0_t = ks.r0_t[t + 1]
r1_t = np.zeros([2, 1])
N0_t = ks.N0_t[t + 1]
N1_t = np.zeros([2, 2])
N2_t = np.zeros([2, 2])
r0_1t = (L0.T).dot(r0_t)
r1_1t = (Ht.T).dot(Upsilon_1).dot(vt) + \
(L0.T).dot(r1_t) + (L1.T).dot(r0_t)
e_xi_T = xi_t + P_star_t.dot(r0_1t) + P_inf_t.dot(r1_1t)
N0_1t = (L0.T).dot(N0_t).dot(L0)
N1_1t = (Ht.T).dot(Upsilon_1).dot(Ht) + (L0.T).dot(N1_t).dot(L0.T) + \
(L1.T).dot(N0_t).dot(L0) + (L0.T).dot(N0_t).dot(L1)
N2_1t = (Ht.T).dot(Upsilon_2).dot(Ht) + (L0.T).dot(N2_t).dot(L0) + \
(L0.T).dot(N1_t).dot(L1) + (L1.T).dot(N1_t.T).dot(L0) + \
(L1.T).dot(N0_t).dot(L1)
e_P_T = P_star_t - P_star_t.dot(N0_1t).dot(P_star_t) - P_star_t.dot(
N1_1t).dot(P_inf_t) - P_inf_t.dot(N1_1t).dot(P_star_t) - \
P_inf_t.dot(N2_1t).dot(P_inf_t)
e_P_cov_t_t1 = (P_star_t.dot(L0.T) + P_inf_t.dot(L1.T)).dot(
ks.I - N1_t.dot(ks.P_inf_t[t + 1][0]) -
N0_t.dot(ks.P_star_t[t + 1][0])) - P_inf_t.dot(L0.T).dot(
N2_t.dot(ks.P_inf_t[t + 1][0]) + N1_t.dot(ks.P_star_t[t + 1][0]))
np.testing.assert_array_almost_equal(e_xi_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_P_cov_t_t1, ks.Pcov_t_t1[t])
np.testing.assert_array_almost_equal(r0_1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(r1_1t, ks.r1_t[t])
np.testing.assert_array_almost_equal(N0_1t, ks.N0_t[t])
np.testing.assert_array_almost_equal(N1_1t, ks.N1_t[t])
np.testing.assert_array_almost_equal(N2_1t, ks.N2_t[t])
# Test period 4
t = 3
n_t = ks.n_t[t]
Ft = ks.Ft[t]
Ht = ks.Ht[t][:n_t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
Upsilon_t = Ht.dot(P_t).dot(Ht.T) + Rt
Upsilon_t_inv = linalg.pinv(Upsilon_t)
Kt = P_t.dot(Ht.T).dot(Upsilon_t_inv)
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
Lt = Ft.dot(ks.I - Kt.dot(Ht))
rt = np.zeros([2, 1])
Nt = np.zeros([2, 2])
r1t = (Ht.T).dot(Upsilon_t_inv).dot(vt) + (Lt.T).dot(rt)
N1t = (Ht.T).dot(Upsilon_t_inv).dot(Ht) + \
(Lt.T).dot(Nt).dot(Lt)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
def test_sequential_smooth(ft_ar2_mvar, theta_ar2_mvar, Yt_ar2_mvar,
Xt_ar2_mvar):
"""
Test whether it gives the same result as using direct approach
"""
kf = Filter(ft_ar2_mvar, Yt_ar2_mvar, Xt_ar2_mvar, for_smoother=True)
kf.fit(theta_ar2_mvar)
ks = Smoother()
ks.fit(kf)
# Test period 1
t = 0
Ft = ks.Ft[t]
Ht = ks.Ht[t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
Rt = ks.Rt[t]
Dt = ks.Dt[t]
Upsilon_t = Ht.dot(P_t).dot(Ht.T) + Rt
Upsilon_t_inv = linalg.pinv(Upsilon_t)
Kt = P_t.dot(Ht.T).dot(Upsilon_t_inv)
vt = ks.Yt[t] - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
Lt = Ft.dot(ks.I - Kt.dot(Ht))
rt = ks.r0_t[t + 1]
Nt = ks.N0_t[t + 1]
r1t = (Ht.T).dot(Upsilon_t_inv).dot(vt) + (Lt.T).dot(rt)
N1t = (Ht.T).dot(Upsilon_t_inv).dot(Ht) + \
(Lt.T).dot(Nt).dot(Lt)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
e_P_cov_t_t1 = P_t.dot(Lt.T).dot(ks.I - Nt.dot(ks.P_star_t[t + 1][0]))
e_PL = ks.P_star_t[t][ks.n_t[t]].dot(Ft.T)
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_PL, P_t.dot(Lt.T))
np.testing.assert_array_almost_equal(e_P_cov_t_t1, ks.Pcov_t_t1[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
# Test period 2
t = 1
n_t = ks.n_t[t]
Ft = ks.Ft[t]
Ht = ks.Ht[t][:n_t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
Upsilon_t = Ht.dot(P_t).dot(Ht.T) + Rt
Upsilon_t_inv = linalg.pinv(Upsilon_t)
Kt = P_t.dot(Ht.T).dot(Upsilon_t_inv)
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
Lt = Ft.dot(ks.I - Kt.dot(Ht))
rt = ks.r0_t[t + 1]
Nt = ks.N0_t[t + 1]
r1t = (Ht.T).dot(Upsilon_t_inv).dot(vt) + (Lt.T).dot(rt)
N1t = (Ht.T).dot(Upsilon_t_inv).dot(Ht) + \
(Lt.T).dot(Nt).dot(Lt)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
e_P_cov_t_t1 = P_t.dot(Lt.T).dot(ks.I - Nt.dot(ks.P_star_t[t + 1][0]))
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_P_cov_t_t1, ks.Pcov_t_t1[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
# Test period 3
t = 2
n_t = ks.n_t[t]
Ft = ks.Ft[t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
rt = ks.r0_t[t + 1]
Nt = ks.N0_t[t + 1]
r1t = (Ft.T).dot(rt)
N1t = (Ft.T).dot(Nt).dot(Ft)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
e_P_cov_t_t1 = P_t.dot(Ft.T).dot(ks.I - Nt.dot(ks.P_star_t[t + 1][0]))
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_P_cov_t_t1, ks.Pcov_t_t1[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
# Test period 4
t = 3
n_t = ks.n_t[t]
Ft = ks.Ft[t]
Ht = ks.Ht[t][:n_t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
Upsilon_t = Ht.dot(P_t).dot(Ht.T) + Rt
Upsilon_t_inv = linalg.pinv(Upsilon_t)
Kt = P_t.dot(Ht.T).dot(Upsilon_t_inv)
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
Lt = Ft.dot(ks.I - Kt.dot(Ht))
rt = np.zeros([2, 1])
Nt = np.zeros([2, 2])
r1t = (Ht.T).dot(Upsilon_t_inv).dot(vt) + (Lt.T).dot(rt)
N1t = (Ht.T).dot(Upsilon_t_inv).dot(Ht) + \
(Lt.T).dot(Nt).dot(Lt)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
def test_sequential_smooth_diffuse_vec(ft_ll_mvar_diffuse,
theta_ll_mvar_diffuse,
Yt_mvar_diffuse_smooth_vec):
"""
Test cases with diffuse initial conditions. I test the case
where there are multiple observations at time t, and only the
first measurement matters (in local linear models).
"""
kf = Filter(ft_ll_mvar_diffuse,
Yt_mvar_diffuse_smooth_vec,
for_smoother=True)
kf.fit(theta_ll_mvar_diffuse)
ks = Smoother()
ks.fit(kf)
# Test period 3
t = 2
n_t = ks.n_t[t]
Ft = ks.Ft[t]
Ht = ks.Ht[t][:n_t]
xi_t = ks.xi_t[t][0]
P_t = ks.P_star_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
Upsilon_t = Ht.dot(P_t).dot(Ht.T) + Rt
Upsilon_t_inv = linalg.pinv(Upsilon_t)
Kt = P_t.dot(Ht.T).dot(Upsilon_t_inv)
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
Lt = Ft.dot(ks.I - Kt.dot(Ht))
rt = np.zeros([2, 1])
Nt = np.zeros([2, 2])
r1t = (Ht.T).dot(Upsilon_t_inv).dot(vt) + (Lt.T).dot(rt)
N1t = (Ht.T).dot(Upsilon_t_inv).dot(Ht) + \
(Lt.T).dot(Nt).dot(Lt)
e_xi_t_T = xi_t + P_t.dot(r1t)
e_P_t_T = P_t - P_t.dot(N1t).dot(P_t)
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(r1t, ks.r0_t[t])
np.testing.assert_array_almost_equal(N1t, ks.N0_t[t])
# Test period 2 (refer to Koopman 1997)
t = 1
Ft = ks.Ft[t]
n_t = ks.n_t[t]
xi_t = ks.xi_t[t][0]
Rt = ks.Rt[t][:n_t][:, :n_t]
Ht = ks.Ht[t][:n_t]
Dt = ks.Dt[t][:n_t]
Yt = ks.Yt[t][:n_t]
vt = Yt - Ht.dot(xi_t) - Dt.dot(ks.Xt[t])
P_inf_t = ks.P_inf_t[t][0]
P_star_t = ks.P_star_t[t][0]
r_star_t = ks.r0_t[t + 1]
N_star_t = ks.N0_t[t + 1]
Upsilon_inf_t = Ht.dot(P_inf_t).dot(Ht.T)
Upsilon_star_t = Ht.dot(P_star_t).dot(Ht.T) + Rt
K_ = np.array([[0, 0.5], [0.5, -0.25]])
star = K_.dot(Upsilon_star_t).dot(K_)
L_ = np.eye(2)
L_[0][1] = -star[1][0] / star[1][1]
L_star_L = L_.dot(star).dot(L_.T)
L_[1][1] = 1 / np.sqrt(L_star_L[1][1])
J = (L_.dot(K_)).T
J1 = J[:, 0:1]
J2 = J[:, 1:2]
F_star_neg = J2.dot(J2.T)
F_inf_neg = J1.dot(J1.T)
F2 = -F_inf_neg.dot(Upsilon_star_t).dot(F_inf_neg)
M_star = Ft.dot(P_star_t).dot(Ht.T)
M_inf = Ft.dot(P_inf_t).dot(Ht.T)
K_star = M_star.dot(F_star_neg) + M_inf.dot(F_inf_neg)
K_inf = M_star.dot(F_inf_neg) - M_inf.dot(F_inf_neg).dot(
Upsilon_star_t).dot(F_inf_neg)
L_star = Ft - K_star.dot(Ht)
L_inf = -K_inf.dot(Ht)
r_inf_1t = (Ht.T).dot(F_inf_neg).dot(vt) + (L_inf.T).dot(r_star_t)
r_star_1t = (Ht.T).dot(F_star_neg).dot(vt) + (L_star.T).dot(r_star_t)
N_star_1t = (Ht.T).dot(F_star_neg).dot(Ht) + (
L_star.T).dot(N_star_t).dot(L_star)
N_1_1t = (Ht.T).dot(F_inf_neg).dot(Ht) + (L_inf.T).dot(N_star_t).dot(
L_star) + (L_star.T).dot(N_star_t).dot(L_inf)
N_2_1t = (Ht.T).dot(F2).dot(Ht) + (L_inf.T).dot(N_star_t).dot(L_inf)
e_xi_t_T = xi_t + P_star_t.dot(r_star_1t) + P_inf_t.dot(r_inf_1t)
e_P_t_T = P_star_t - P_star_t.dot(N_star_1t).dot(P_star_t) - \
P_star_t.dot(N_1_1t).dot(P_inf_t) - P_inf_t.dot(N_1_1t).dot(
P_star_t) - P_inf_t.dot(N_2_1t).dot(P_inf_t)
e_Pcov = (P_star_t.dot(L_star.T) + P_inf_t.dot(L_inf.T)).dot(ks.I - \
N_star_t.dot(ks.P_star_t[t+1][0]))
np.testing.assert_array_almost_equal(e_xi_t_T, ks.xi_t_T[t])
np.testing.assert_array_almost_equal(e_P_t_T, ks.P_t_T[t])
np.testing.assert_array_almost_equal(e_Pcov, ks.Pcov_t_t1[t])
