def test_structural_pickle():
mod = structural.UnobservedComponents(macrodata['realgdp'].values,
'llevel')
pkl_mod = cPickle.loads(cPickle.dumps(mod))
res = mod.smooth(mod.start_params)
pkl_res = pkl_mod.smooth(pkl_mod.start_params)
assert_allclose(res.params, pkl_res.params)
assert_allclose(res.bse, pkl_res.bse)
assert_allclose(res.llf, pkl_res.llf)
def test_structural():
mod = structural.UnobservedComponents(
macrodata['realgdp'].values, 'llevel')
res = mod.smooth(mod.start_params)
res.summary()
res.save('test_save_structural.p')
res2 = structural.UnobservedComponentsResults.load(
'test_save_structural.p')
assert_allclose(res.params, res2.params)
assert_allclose(res.bse, res2.bse)
assert_allclose(res.llf, res2.llf)
os.unlink('test_save_structural.p')
def test_known_initialization():
# Need to test that "known" initialization is taken into account in
# time series simulation
np.random.seed(38947)
nobs = 100
eps = np.random.normal(size=nobs)
eps1 = np.zeros(nobs)
eps2 = np.zeros(nobs)
eps2[49] = 1
eps3 = np.zeros(nobs)
eps3[50:] = 1
# SARIMAX
# (test that when state shocks are shut down, the initial state
# geometrically declines according to the AR parameter)
mod = sarimax.SARIMAX([0], order=(1, 0, 0))
mod.ssm.initialize_known([100], [[0]])
actual = mod.simulate([0.5, 1.], nobs, state_shocks=eps1)
assert_allclose(actual, 100 * 0.5**np.arange(nobs))
# Unobserved components
# (test that the initial level shifts the entire path)
mod = structural.UnobservedComponents([0], 'local level')
mod.ssm.initialize_known([100], [[0]])
actual = mod.simulate([1., 1.], nobs, measurement_shocks=eps,
state_shocks=eps2)
assert_allclose(actual, 100 + eps + eps3)
# VARMAX
# (here just test that with an independent VAR we have each initial state
# geometrically declining at the appropriate rate)
transition = np.diag([0.5, 0.2])
mod = varmax.VARMAX([[0, 0]], order=(1, 0), trend='nc')
mod.initialize_known([100, 50], np.diag([0, 0]))
actual = mod.simulate(np.r_[transition.ravel(), 1., 0, 1.], nobs,
measurement_shocks=np.c_[eps1, eps1],
state_shocks=np.c_[eps1, eps1])
assert_allclose(actual, np.c_[100 * 0.5**np.arange(nobs),
50 * 0.2**np.arange(nobs)])
# Dynamic factor
# (test that the initial state declines geometrically and then loads
# correctly onto the series)
mod = dynamic_factor.DynamicFactor([[0, 0]], k_factors=1, factor_order=1)
mod.initialize_known([100], [[0]])
print(mod.param_names)
actual = mod.simulate([0.8, 0.2, 1.0, 1.0, 0.5], nobs,
measurement_shocks=np.c_[eps1, eps1],
state_shocks=eps1)
tmp = 100 * 0.5**np.arange(nobs)
assert_allclose(actual, np.c_[0.8 * tmp, 0.2 * tmp])
def test_structural_invalid():
# Test for invalid uses of parameter fixing
endog = macrodata['infl']
mod1 = structural.UnobservedComponents(endog, 'rwalk', ar=2)
# Try to fix invalid parameter
assert_raises(ValueError, mod1.fit_constrained, {'AR.L1': 0.5})
# Cannot fix parameters that are part of a multivariate transformation
with pytest.raises(ValueError):
with mod1.fix_params({'ar.L1': 0.5}):
pass
assert_raises(ValueError, mod1.fit_constrained, {'ar.L1': 0.5})
def test_unobserved_components(missing, periods, use_exact_diffuse):
endog = np.array([0.5, 1.2, -0.2, 0.3, -0.1, 0.4, 1.4, 0.9])
exog = np.ones_like(endog)
if missing == 'init':
endog[0:2] = np.nan
elif missing == 'mixed':
endog[2:4] = np.nan
elif missing == 'all':
endog[:] = np.nan
mod = structural.UnobservedComponents(endog,
'llevel',
exog=exog,
seasonal=2,
autoregressive=1,
use_exact_diffuse=use_exact_diffuse)
mod.update([1.0, 0.1, 0.3, 0.05, 0.15, 0.5])
check_filter_output(mod, periods)
check_smoother_output(mod, periods)
def test_structural_validate():
# Test for invalid uses of parameter fixing
endog = macrodata['infl']
mod1 = structural.UnobservedComponents(endog, 'rwalk', autoregressive=2)
# Try to fix invalid parameter
assert_raises(ValueError, mod1.fit_constrained, {'AR.L1': 0.5})
# Cannot fix parameters that are part of a multivariate transformation
with pytest.raises(ValueError):
with mod1.fix_params({'ar.L1': 0.5}):
pass
assert_raises(ValueError, mod1.fit_constrained, {'ar.L1': 0.5})
# But can fix the entire set of parameters that are part of a multivariate
# transformation
with mod1.fix_params({'ar.L1': 0.5, 'ar.L2': 0.2}):
assert_(mod1._has_fixed_params)
assert_equal(mod1._fixed_params, {'ar.L1': 0.5, 'ar.L2': 0.2})
assert_equal(mod1._fixed_params_index, [2, 3])
assert_equal(mod1._free_params_index, [0, 1])
res = mod1.fit_constrained({
'ar.L1': 0.5,
'ar.L2': 0.2
},
start_params=[7.0],
disp=False)
assert_(res._has_fixed_params)
assert_equal(res._fixed_params, {'ar.L1': 0.5, 'ar.L2': 0.2})
assert_equal(res._fixed_params_index, [2, 3])
assert_equal(res._free_params_index, [0, 1])
with mod1.fix_params({'ar.L1': 0.5, 'ar.L2': 0.}):
# overwrite ar.L2 with nested fix_params
with mod1.fix_params({'ar.L2': 0.2}):
assert_(mod1._has_fixed_params)
assert_equal(mod1._fixed_params, {'ar.L1': 0.5, 'ar.L2': 0.2})
assert_equal(mod1._fixed_params_index, [2, 3])
assert_equal(mod1._free_params_index, [0, 1])
def test_structural():
# Clear warnings
structural.__warningregistry__ = {}
np.random.seed(38947)
nobs = 100
eps = np.random.normal(size=nobs)
exog = np.random.normal(size=nobs)
eps1 = np.zeros(nobs)
eps2 = np.zeros(nobs)
eps2[49] = 1
eps3 = np.zeros(nobs)
eps3[50:] = 1
# AR(1)
mod1 = structural.UnobservedComponents([0], autoregressive=1)
mod2 = sarimax.SARIMAX([0], order=(1, 0, 0))
actual = mod1.simulate([1, 0.5],
nobs,
state_shocks=eps,
initial_state=np.zeros(mod1.k_states))
desired = mod2.simulate([0.5, 1],
nobs,
state_shocks=eps,
initial_state=np.zeros(mod2.k_states))
assert_allclose(actual, desired)
# ARX(1)
mod1 = structural.UnobservedComponents(np.zeros(nobs),
exog=exog,
autoregressive=1)
mod2 = sarimax.SARIMAX(np.zeros(nobs), exog=exog, order=(1, 0, 0))
actual = mod1.simulate([1, 0.5, 0.2],
nobs,
state_shocks=eps,
initial_state=np.zeros(mod2.k_states))
desired = mod2.simulate([0.2, 0.5, 1],
nobs,
state_shocks=eps,
initial_state=np.zeros(mod2.k_states))
assert_allclose(actual, desired)
# Irregular
mod = structural.UnobservedComponents([0], 'irregular')
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
initial_state=np.zeros(mod.k_states))
assert_allclose(actual, eps)
# Fixed intercept
# (in practice this is a deterministic constant, because an irregular
# component must be added)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mod = structural.UnobservedComponents([0], 'fixed intercept')
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
initial_state=[10])
assert_allclose(actual, 10 + eps)
# Deterministic constant
mod = structural.UnobservedComponents([0], 'deterministic constant')
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
initial_state=[10])
assert_allclose(actual, 10 + eps)
# Local level
mod = structural.UnobservedComponents([0], 'local level')
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=np.zeros(mod.k_states))
assert_allclose(actual, eps + eps3)
# Random walk
mod = structural.UnobservedComponents([0], 'random walk')
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=np.zeros(mod.k_states))
assert_allclose(actual, eps + eps3)
# Fixed slope
# (in practice this is a deterministic trend, because an irregular
# component must be added)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mod = structural.UnobservedComponents([0], 'fixed slope')
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=[0, 1])
assert_allclose(actual, eps + np.arange(100))
# Deterministic trend
mod = structural.UnobservedComponents([0], 'deterministic trend')
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=[0, 1])
assert_allclose(actual, eps + np.arange(100))
# Local linear deterministic trend
mod = structural.UnobservedComponents([0],
'local linear deterministic trend')
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=[0, 1])
desired = eps + np.r_[np.arange(50), 1 + np.arange(50, 100)]
assert_allclose(actual, desired)
# Random walk with drift
mod = structural.UnobservedComponents([0], 'random walk with drift')
actual = mod.simulate([1.], nobs, state_shocks=eps2, initial_state=[0, 1])
desired = np.r_[np.arange(50), 1 + np.arange(50, 100)]
assert_allclose(actual, desired)
# Local linear trend
mod = structural.UnobservedComponents([0], 'local linear trend')
actual = mod.simulate([1., 1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=np.c_[eps2, eps1],
initial_state=[0, 1])
desired = eps + np.r_[np.arange(50), 1 + np.arange(50, 100)]
assert_allclose(actual, desired)
actual = mod.simulate([1., 1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=np.c_[eps1, eps2],
initial_state=[0, 1])
desired = eps + np.r_[np.arange(50), np.arange(50, 150, 2)]
assert_allclose(actual, desired)
# Smooth trend
mod = structural.UnobservedComponents([0], 'smooth trend')
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps1,
initial_state=[0, 1])
desired = eps + np.r_[np.arange(100)]
assert_allclose(actual, desired)
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=[0, 1])
desired = eps + np.r_[np.arange(50), np.arange(50, 150, 2)]
assert_allclose(actual, desired)
# Random trend
mod = structural.UnobservedComponents([0], 'random trend')
actual = mod.simulate([1., 1.],
nobs,
state_shocks=eps1,
initial_state=[0, 1])
desired = np.r_[np.arange(100)]
assert_allclose(actual, desired)
actual = mod.simulate([1., 1.],
nobs,
state_shocks=eps2,
initial_state=[0, 1])
desired = np.r_[np.arange(50), np.arange(50, 150, 2)]
assert_allclose(actual, desired)
# Seasonal (deterministic)
mod = structural.UnobservedComponents([0],
'irregular',
seasonal=2,
stochastic_seasonal=False)
actual = mod.simulate([1.],
nobs,
measurement_shocks=eps,
initial_state=[10])
desired = eps + np.tile([10, -10], 50)
assert_allclose(actual, desired)
# Seasonal (stochastic)
mod = structural.UnobservedComponents([0], 'irregular', seasonal=2)
actual = mod.simulate([1., 1.],
nobs,
measurement_shocks=eps,
state_shocks=eps2,
initial_state=[10])
desired = eps + np.r_[np.tile([10, -10], 25), np.tile([11, -11], 25)]
assert_allclose(actual, desired)
# Cycle (deterministic)
mod = structural.UnobservedComponents([0], 'irregular', cycle=True)
actual = mod.simulate([1., 1.2],
nobs,
measurement_shocks=eps,
initial_state=[1, 0])
x1 = [np.cos(1.2), np.sin(1.2)]
x2 = [-np.sin(1.2), np.cos(1.2)]
T = np.array([x1, x2])
desired = eps
states = [1, 0]
for i in range(nobs):
desired[i] += states[0]
states = np.dot(T, states)
assert_allclose(actual, desired)
# Cycle (stochastic)
mod = structural.UnobservedComponents([0],
'irregular',
cycle=True,
stochastic_cycle=True)
actual = mod.simulate([1., 1., 1.2],
nobs,
measurement_shocks=eps,
state_shocks=np.c_[eps2, eps2],
initial_state=[1, 0])
x1 = [np.cos(1.2), np.sin(1.2)]
x2 = [-np.sin(1.2), np.cos(1.2)]
T = np.array([x1, x2])
desired = eps
states = [1, 0]
for i in range(nobs):
desired[i] += states[0]
states = np.dot(T, states) + eps2[i]
assert_allclose(actual, desired)
def test_structural():
steps = 10
# AR(1)
mod = structural.UnobservedComponents([0], autoregressive=1)
phi = 0.5
actual = mod.impulse_responses([1, phi], steps)
desired = np.r_[[phi**i for i in range(steps + 1)]]
assert_allclose(actual, desired)
# ARX(1)
# This is adequately tested in test_simulate.py, since in the time-varying
# case `impulse_responses` just calls `simulate`
# Irregular
mod = structural.UnobservedComponents([0], 'irregular')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Fixed intercept
# (in practice this is a deterministic constant, because an irregular
# component must be added)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mod = structural.UnobservedComponents([0], 'fixed intercept')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Deterministic constant
mod = structural.UnobservedComponents([0], 'deterministic constant')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Local level
mod = structural.UnobservedComponents([0], 'local level')
actual = mod.impulse_responses([1., 1.], steps)
assert_allclose(actual, 1)
# Random walk
mod = structural.UnobservedComponents([0], 'random walk')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 1)
# Fixed slope
# (in practice this is a deterministic trend, because an irregular
# component must be added)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mod = structural.UnobservedComponents([0], 'fixed slope')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Deterministic trend
mod = structural.UnobservedComponents([0], 'deterministic trend')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Local linear deterministic trend
mod = structural.UnobservedComponents([0],
'local linear deterministic trend')
actual = mod.impulse_responses([1., 1.], steps)
assert_allclose(actual, 1)
# Random walk with drift
mod = structural.UnobservedComponents([0], 'random walk with drift')
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 1)
# Local linear trend
mod = structural.UnobservedComponents([0], 'local linear trend')
# - shock the level
actual = mod.impulse_responses([1., 1., 1.], steps)
assert_allclose(actual, 1)
# - shock the trend
actual = mod.impulse_responses([1., 1., 1.], steps, impulse=1)
assert_allclose(actual, np.arange(steps + 1))
# Smooth trend
mod = structural.UnobservedComponents([0], 'smooth trend')
actual = mod.impulse_responses([1., 1.], steps)
assert_allclose(actual, np.arange(steps + 1))
# Random trend
mod = structural.UnobservedComponents([0], 'random trend')
actual = mod.impulse_responses([1., 1.], steps)
assert_allclose(actual, np.arange(steps + 1))
# Seasonal (deterministic)
mod = structural.UnobservedComponents([0],
'irregular',
seasonal=2,
stochastic_seasonal=False)
actual = mod.impulse_responses([1.], steps)
assert_allclose(actual, 0)
# Seasonal (stochastic)
mod = structural.UnobservedComponents([0], 'irregular', seasonal=2)
actual = mod.impulse_responses([1., 1.], steps)
desired = np.r_[1, np.tile([-1, 1], steps // 2)]
assert_allclose(actual, desired)
# Cycle (deterministic)
mod = structural.UnobservedComponents([0], 'irregular', cycle=True)
actual = mod.impulse_responses([1., 1.2], steps)
assert_allclose(actual, 0)
# Cycle (stochastic)
mod = structural.UnobservedComponents([0],
'irregular',
cycle=True,
stochastic_cycle=True)
actual = mod.impulse_responses([1., 1., 1.2], steps=10)
x1 = [np.cos(1.2), np.sin(1.2)]
x2 = [-np.sin(1.2), np.cos(1.2)]
T = np.array([x1, x2])
desired = np.zeros(steps + 1)
states = [1, 0]
for i in range(steps + 1):
desired[i] += states[0]
states = np.dot(T, states)
assert_allclose(actual, desired)
