def test_ar_plot(self):
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(disp=DISPLAY, update_freq=5, cov_type='mle')
res.plot()
res.plot(annualize='D')
res.plot(annualize='W')
res.plot(annualize='M')
with pytest.raises(ValueError):
res.plot(annualize='unknown')
res.plot(scale=360)
res.hedgehog_plot(start=500)
res.hedgehog_plot(start=500, type='mean')
res.hedgehog_plot(type='volatility')
res.hedgehog_plot(start=500, method='simulation', simulations=100)
def test_warnings(self):
with warnings.catch_warnings(record=True) as w:
ARX(self.y, lags=[1, 2, 3, 12], hold_back=5)
assert_equal(len(w), 1)
with warnings.catch_warnings(record=True) as w:
HARX(self.y, lags=[[1, 1, 1], [2, 5, 22]], use_rotated=True)
assert_equal(len(w), 1)
def test_errors(self):
assert_raises(ValueError, ARX, self.y, lags=np.array([[1, 2], [3, 4]]))
x = randn(self.y.shape[0] + 1, 1)
assert_raises(ValueError, ARX, self.y, x=x)
assert_raises(ValueError, HARX, self.y, lags=np.eye(3))
assert_raises(ValueError, ARX, self.y, lags=-1)
assert_raises(ValueError, ARX, self.y, x=randn(1, 1), lags=-1)
ar = ARX(self.y, lags=1)
with self.assertRaises(ValueError):
d = Normal()
ar.volatility = d
with self.assertRaises(ValueError):
v = GARCH()
ar.distribution = v
x = randn(1000, 1)
assert_raises(ValueError, ar.simulate, np.ones(5), 100, x=x)
assert_raises(ValueError, ar.simulate, np.ones(5), 100)
assert_raises(ValueError,
ar.simulate,
np.ones(3),
100,
initial_value=randn(10))
with self.assertRaises(ValueError):
ar.volatility = ConstantVariance()
ar.fit(cov_type='unknown')
def test_constant_mean_fixed_variance(self):
variance = 2 + self.rng.standard_normal(self.y.shape[0]) ** 2.0
mod = ConstantMean(self.y_series, volatility=FixedVariance(variance))
res = mod.fit()
print(res.summary())
assert len(res.params) == 2
assert 'scale' in res.params.index
mod = ARX(self.y_series, lags=[1, 2, 3], volatility=FixedVariance(variance))
res = mod.fit()
assert len(res.params) == 5
assert 'scale' in res.params.index
mod = ARX(self.y_series, lags=[1, 2, 3],
volatility=FixedVariance(variance, unit_scale=True))
res = mod.fit()
assert len(res.params) == 4
assert 'scale' not in res.params.index
def test_no_param_volatility(self):
cm = ConstantMean(self.y)
cm.volatility = EWMAVariance()
cm.fit(update_freq=0)
cm.volatility = RiskMetrics2006()
cm.fit(update_freq=0)
ar = ARX(self.y, lags=5)
ar.volatility = EWMAVariance()
ar.fit(update_freq=0)
ar.volatility = RiskMetrics2006()
ar.fit(update_freq=0)
def test_errors(self):
assert_raises(ValueError, ARX, self.y, lags=np.array([[1, 2], [3, 4]]))
x = randn(self.y.shape[0] + 1, 1)
assert_raises(ValueError, ARX, self.y, x=x)
assert_raises(ValueError, HARX, self.y, lags=np.eye(3))
assert_raises(ValueError, ARX, self.y, lags=-1)
assert_raises(ValueError, ARX, self.y, x=randn(1, 1), lags=-1)
ar = ARX(self.y, lags=1)
with self.assertRaises(ValueError):
d = Normal()
ar.volatility = d
with self.assertRaises(ValueError):
v = GARCH()
ar.distribution = v
x = randn(1000, 1)
assert_raises(ValueError, ar.simulate, np.ones(5), 100, x=x)
assert_raises(ValueError, ar.simulate, np.ones(5), 100)
assert_raises(ValueError, ar.simulate, np.ones(3), 100,
initial_value=randn(10))
with self.assertRaises(ValueError):
ar.volatility = ConstantVariance()
ar.fit(cov_type='unknown')
def test_ar_plot(self):
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(disp=DISPLAY, update_freq=5, cov_type="mle")
res.plot()
res.plot(annualize="D")
res.plot(annualize="W")
res.plot(annualize="M")
with pytest.raises(ValueError):
res.plot(annualize="unknown")
import matplotlib.pyplot as plt
plt.close("all")
res.plot(scale=360)
res.hedgehog_plot(start=500)
res.hedgehog_plot(start=500, plot_type="mean")
res.hedgehog_plot(plot_type="volatility")
res.hedgehog_plot(start=500, method="simulation", simulations=100)
res.hedgehog_plot(plot_type="volatility", method="bootstrap")
plt.close("all")
def test_no_param_volatility(self):
cm = ConstantMean(self.y)
cm.volatility = EWMAVariance()
cm.fit(update_freq=0, disp=DISPLAY)
cm.volatility = RiskMetrics2006()
cm.fit(update_freq=0, disp=DISPLAY)
ar = ARX(self.y, lags=5)
ar.volatility = EWMAVariance()
ar.fit(update_freq=0, disp=DISPLAY)
ar.volatility = RiskMetrics2006()
ar.fit(update_freq=0, disp=DISPLAY)
assert 'tau0' in str(ar.volatility)
assert 'tau1' in str(ar.volatility)
assert 'kmax' in str(ar.volatility)
def test_no_param_volatility(self):
cm = ConstantMean(self.y)
cm.volatility = EWMAVariance()
cm.fit(update_freq=0)
cm.volatility = RiskMetrics2006()
cm.fit(update_freq=0)
ar = ARX(self.y, lags=5)
ar.volatility = EWMAVariance()
ar.fit(update_freq=0)
ar.volatility = RiskMetrics2006()
ar.fit(update_freq=0)
def test_har_lag_specifications(self):
""" Test equivalence of alternative lag specifications"""
har = HARX(self.y, lags=[1, 2, 3])
har_r = HARX(self.y, lags=[1, 2, 3], use_rotated=True)
har_r_v2 = HARX(self.y, lags=3, use_rotated=True)
ar = ARX(self.y, lags=[1, 2, 3])
ar_v2 = ARX(self.y, lags=3)
res_har = har.fit(disp=DISPLAY)
res_har_r = har_r.fit(disp=DISPLAY)
res_har_r_v2 = har_r_v2.fit(disp=DISPLAY)
res_ar = ar.fit(disp=DISPLAY)
res_ar_v2 = ar_v2.fit(disp=DISPLAY)
assert_almost_equal(res_har.rsquared, res_har_r.rsquared)
assert_almost_equal(res_har_r_v2.rsquared, res_har_r.rsquared)
assert_almost_equal(np.asarray(res_ar.params),
np.asarray(res_ar_v2.params))
assert_almost_equal(np.asarray(res_ar.params),
np.asarray(res_har_r_v2.params))
assert_almost_equal(np.asarray(res_ar.param_cov),
np.asarray(res_har_r_v2.param_cov))
assert_almost_equal(res_ar.conditional_volatility,
res_har_r_v2.conditional_volatility)
assert_almost_equal(res_ar.resid, res_har_r_v2.resid)
def test_no_param_volatility(self):
cm = ConstantMean(self.y)
cm.volatility = EWMAVariance()
cm.fit(update_freq=0, disp=DISPLAY)
cm.volatility = RiskMetrics2006()
cm.fit(update_freq=0, disp=DISPLAY)
ar = ARX(self.y, lags=5)
ar.volatility = EWMAVariance()
ar.fit(update_freq=0, disp=DISPLAY)
ar.volatility = RiskMetrics2006()
ar.fit(update_freq=0, disp=DISPLAY)
assert 'tau0' in str(ar.volatility)
assert 'tau1' in str(ar.volatility)
assert 'kmax' in str(ar.volatility)
def test_arx(self):
arx = ARX(self.y,
self.x,
lags=3,
hold_back=10,
last_obs=900,
constant=False)
params = np.array([0.4, 0.3, 0.2, 1.0, 1.0])
data = arx.simulate(params, self.T, x=randn(self.T + 500, 1))
bounds = arx.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(arx.num_params, 4)
assert_true(not arx.constant)
a, b = arx.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = arx.fit()
nobs = 900 - 10
rhs = np.zeros((nobs, 4))
y = self.y
lhs = y[10:900]
for i in range(10, 900):
rhs[i - 10, 0] = y[i - 1]
rhs[i - 10, 1] = y[i - 2]
rhs[i - 10, 2] = y[i - 3]
rhs[:, 3] = self.x[10:900, 0]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
assert_raises(RuntimeError, res.forecast)
assert_equal(arx.first_obs, 10)
assert_equal(arx.last_obs, 900)
assert_equal(arx.hold_back, 10)
assert_equal(arx.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(arx.nobs, 890)
assert_equal(arx.name, 'AR-X')
assert_equal(arx.use_rotated, False)
arx
arx._repr_html_()
def test_arx(self):
arx = ARX(self.y, self.x, lags=3, hold_back=10, constant=False)
params = np.array([0.4, 0.3, 0.2, 1.0, 1.0])
data = arx.simulate(params, self.T, x=self.rng.randn(self.T + 500, 1))
assert isinstance(data, pd.DataFrame)
bounds = arx.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(arx.num_params, 4)
assert not arx.constant
a, b = arx.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = arx.fit(last_obs=900, disp=DISPLAY)
assert res.fit_stop == 900
nobs = 900 - 10
rhs = np.zeros((nobs, 4))
y = self.y
lhs = y[10:900]
for i in range(10, 900):
rhs[i - 10, 0] = y[i - 1]
rhs[i - 10, 1] = y[i - 2]
rhs[i - 10, 2] = y[i - 3]
rhs[:, 3] = self.x[10:900, 0]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
assert_equal(arx.hold_back, 10)
assert_equal(arx.lags, np.array([[1, 2, 3], [1, 2, 3]]))
assert_equal(arx.name, "AR-X")
assert_equal(arx.use_rotated, False)
assert isinstance(arx.__repr__(), str)
arx._repr_html_()
def test_arx(self):
arx = ARX(self.y, self.x, lags=3, hold_back=10, last_obs=900,
constant=False)
params = np.array([0.4, 0.3, 0.2, 1.0, 1.0])
data = arx.simulate(params, self.T, x=randn(self.T + 500, 1))
bounds = arx.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(arx.num_params, 4)
assert_true(not arx.constant)
a, b = arx.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = arx.fit()
nobs = 900 - 10
rhs = np.zeros((nobs, 4))
y = self.y
lhs = y[10:900]
for i in range(10, 900):
rhs[i - 10, 0] = y[i - 1]
rhs[i - 10, 1] = y[i - 2]
rhs[i - 10, 2] = y[i - 3]
rhs[:, 3] = self.x[10:900, 0]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
assert_raises(RuntimeError, res.forecast)
assert_equal(arx.first_obs, 10)
assert_equal(arx.last_obs, 900)
assert_equal(arx.hold_back, 10)
assert_equal(arx.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(arx.nobs, 890)
assert_equal(arx.name, 'AR-X')
assert_equal(arx.use_rotated, False)
arx
arx._repr_html_()
def test_har_lag_specifications(self):
""" Test equivalence of alternative lag specifications"""
har = HARX(self.y, lags=[1, 2, 3])
har_r = HARX(self.y, lags=[1, 2, 3], use_rotated=True)
har_r_v2 = HARX(self.y, lags=3, use_rotated=True)
ar = ARX(self.y, lags=[1, 2, 3])
ar_v2 = ARX(self.y, lags=3)
res_har = har.fit(disp=DISPLAY)
res_har_r = har_r.fit(disp=DISPLAY)
res_har_r_v2 = har_r_v2.fit(disp=DISPLAY)
res_ar = ar.fit(disp=DISPLAY)
res_ar_v2 = ar_v2.fit(disp=DISPLAY)
assert_almost_equal(res_har.rsquared, res_har_r.rsquared)
assert_almost_equal(res_har_r_v2.rsquared, res_har_r.rsquared)
assert_almost_equal(np.asarray(res_ar.params),
np.asarray(res_ar_v2.params))
assert_almost_equal(np.asarray(res_ar.params),
np.asarray(res_har_r_v2.params))
assert_almost_equal(np.asarray(res_ar.param_cov),
np.asarray(res_har_r_v2.param_cov))
assert_almost_equal(res_ar.conditional_volatility,
res_har_r_v2.conditional_volatility)
assert_almost_equal(res_ar.resid, res_har_r_v2.resid)
def test_arch_arx(self):
self.rng.seed(12345)
x = self.rng.randn(500, 3)
y = x.sum(1) + 3 * self.rng.randn(500)
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
am = ARX(y=y, lags=2, x=x)
res = am.fit(disp=DISPLAY)
summ = res.summary().as_text()
repr = res.__repr__()
assert str(hex(id(res))) in repr
assert summ[:10] == repr[:10]
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'y[1]', 'y[2]', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
x = pd.DataFrame(x, columns=['x0', 'x1', 'x2'])
y = pd.Series(y, name='y')
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
def test_ar_no_lags(self):
ar = ARX(self.y, lags=0)
assert ar.lags is None
res = ar.fit()
assert_almost_equal(res.params[0], self.y.mean())
assert 'lags: none' in ar.__str__()
def test_ar(self):
ar = ARX(self.y, lags=3)
params = np.array([1.0, 0.4, 0.3, 0.2, 1.0])
data = ar.simulate(params, self.T)
assert len(data) == self.T
assert_equal(self.y, ar.y)
bounds = ar.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(ar.num_params, 4)
assert ar.constant
a, b = ar.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = ar.fit(disp=DISPLAY)
nobs = 1000 - 3
rhs = np.ones((nobs, 4))
y = self.y
lhs = y[3:1000]
for i in range(3, 1000):
rhs[i - 3, 1] = y[i - 1]
rhs[i - 3, 2] = y[i - 2]
rhs[i - 3, 3] = y[i - 3]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
forecasts = res.forecast(horizon=5)
direct = pd.DataFrame(index=np.arange(y.shape[0]),
columns=['h.' + str(i + 1) for i in range(5)],
dtype=np.float64)
params = res.params.iloc[:-1]
for i in range(2, y.shape[0]):
fcast = np.zeros(y.shape[0] + 5)
fcast[:y.shape[0]] = y.copy()
for h in range(1, 6):
reg = np.array([1.0, fcast[i + h - 1],
fcast[i + h - 2], fcast[i + h - 3]])
fcast[i + h] = reg.dot(params)
direct.iloc[i, :] = fcast[i + 1:i + 6]
assert isinstance(forecasts, ARCHModelForecast)
# TODO
# assert_frame_equal(direct, forecasts)
assert_equal(ar.hold_back, None)
assert_equal(ar.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(ar.name, 'AR')
assert_equal(ar.use_rotated, False)
ar.__repr__()
ar._repr_html_()
ar = ARX(self.y_df, lags=5)
ar.__repr__()
ar = ARX(self.y_series, lags=5)
ar.__repr__()
res = ar.fit(disp=DISPLAY)
assert isinstance(res.resid, pd.Series)
assert isinstance(res.conditional_volatility, pd.Series)
# Smoke bootstrap
summ = ar.fit(disp=DISPLAY).summary()
assert 'Constant Variance' in str(summ)
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(disp=DISPLAY, update_freq=5, cov_type='mle')
res.param_cov
sims = res.forecast(horizon=5, method='simulation')
assert isinstance(sims.simulations.residual_variances, np.ndarray)
assert isinstance(sims.simulations.residuals, np.ndarray)
assert isinstance(sims.simulations.values, np.ndarray)
assert isinstance(sims.simulations.variances, np.ndarray)
def test_errors(self):
with pytest.raises(ValueError):
ARX(self.y, lags=np.array([[1, 2], [3, 4]]))
x = self.rng.randn(self.y.shape[0] + 1, 1)
with pytest.raises(ValueError):
ARX(self.y, x=x)
with pytest.raises(ValueError):
HARX(self.y, lags=np.eye(3))
with pytest.raises(ValueError):
ARX(self.y, lags=-1)
with pytest.raises(ValueError):
ARX(self.y, x=self.rng.randn(1, 1), lags=-1)
ar = ARX(self.y, lags=1)
with pytest.raises(ValueError):
d = Normal()
ar.volatility = d
with pytest.raises(ValueError):
v = GARCH()
ar.distribution = v
x = self.rng.randn(1000, 1)
with pytest.raises(ValueError):
ar.simulate(np.ones(5), 100, x=x)
with pytest.raises(ValueError):
ar.simulate(np.ones(5), 100)
with pytest.raises(ValueError):
ar.simulate(np.ones(3), 100, initial_value=self.rng.standard_normal(10))
with pytest.raises(ValueError):
ar.volatility = ConstantVariance()
ar.fit(cov_type="unknown")
def test_ar(self):
ar = ARX(self.y, lags=3)
params = np.array([1.0, 0.4, 0.3, 0.2, 1.0])
data = ar.simulate(params, self.T)
assert len(data) == self.T
assert_equal(self.y, ar.y)
bounds = ar.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(ar.num_params, 4)
assert ar.constant
a, b = ar.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = ar.fit(disp=DISPLAY)
nobs = 1000 - 3
rhs = np.ones((nobs, 4))
y = self.y
lhs = y[3:1000]
for i in range(3, 1000):
rhs[i - 3, 1] = y[i - 1]
rhs[i - 3, 2] = y[i - 2]
rhs[i - 3, 3] = y[i - 3]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
forecasts = res.forecast(horizon=5)
direct = pd.DataFrame(index=np.arange(y.shape[0]),
columns=['h.' + str(i + 1) for i in range(5)],
dtype=np.float64)
params = res.params.iloc[:-1]
for i in range(2, y.shape[0]):
fcast = np.zeros(y.shape[0] + 5)
fcast[:y.shape[0]] = y.copy()
for h in range(1, 6):
reg = np.array([1.0, fcast[i + h - 1],
fcast[i + h - 2], fcast[i + h - 3]])
fcast[i + h] = reg.dot(params)
direct.iloc[i, :] = fcast[i + 1:i + 6]
assert isinstance(forecasts, ARCHModelForecast)
# TODO
# assert_frame_equal(direct, forecasts)
assert_equal(ar.hold_back, None)
assert_equal(ar.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(ar.name, 'AR')
assert_equal(ar.use_rotated, False)
ar.__repr__()
ar._repr_html_()
ar = ARX(self.y_df, lags=5)
ar.__repr__()
ar = ARX(self.y_series, lags=5)
ar.__repr__()
res = ar.fit(disp=DISPLAY)
assert isinstance(res.resid, pd.Series)
assert isinstance(res.conditional_volatility, pd.Series)
# Smoke bootstrap
summ = ar.fit(disp=DISPLAY).summary()
assert 'Constant Variance' in str(summ)
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(disp=DISPLAY, update_freq=5, cov_type='mle')
res.param_cov
def test_ar(self):
ar = ARX(self.y, lags=3)
params = np.array([1.0, 0.4, 0.3, 0.2, 1.0])
data = ar.simulate(params, self.T)
assert_equal(self.y, ar.y)
bounds = ar.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(ar.num_params, 4)
assert_true(ar.constant)
a, b = ar.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = ar.fit()
nobs = 1000 - 3
rhs = np.ones((nobs, 4))
y = self.y
lhs = y[3:1000]
for i in range(3, 1000):
rhs[i - 3, 1] = y[i - 1]
rhs[i - 3, 2] = y[i - 2]
rhs[i - 3, 3] = y[i - 3]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
forecasts = res.forecast(horizon=5)
direct = pd.DataFrame(index=np.arange(y.shape[0]),
columns=['h.' + str(i + 1) for i in range(5)],
dtype=np.float64)
params = res.params.iloc[:-1]
for i in range(2, y.shape[0]):
fcast = np.zeros(y.shape[0] + 5)
fcast[:y.shape[0]] = y.copy()
for h in range(1, 6):
reg = np.array([
1.0, fcast[i + h - 1], fcast[i + h - 2], fcast[i + h - 3]
])
fcast[i + h] = reg.dot(params)
direct.iloc[i, :] = fcast[i + 1:i + 6]
assert_frame_equal(direct, forecasts)
assert_equal(ar.first_obs, 3)
assert_equal(ar.last_obs, 1000)
assert_equal(ar.hold_back, None)
assert_equal(ar.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(ar.nobs, 997)
assert_equal(ar.name, 'AR')
assert_equal(ar.use_rotated, False)
ar.__repr__()
ar._repr_html_()
ar = ARX(self.y_df, lags=5)
ar.__repr__()
ar = ARX(self.y_series, lags=5)
ar.__repr__()
res = ar.fit()
assert_true(isinstance(res.resid, pd.Series))
assert_true(isinstance(res.conditional_volatility, pd.Series))
# Smoke tests
summ = ar.fit().summary()
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(update_freq=5, cov_type='mle')
res.param_cov
res.plot()
res.plot(annualize='D')
res.plot(annualize='W')
res.plot(annualize='M')
assert_raises(ValueError, res.plot, annualize='unknown')
res.plot(scale=360)
res.hedgehog_plot()
def test_first_last_obs(self):
ar = ARX(self.y, lags=5, hold_back=100)
res = ar.fit(update_freq=0, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
assert_equal(resids, resid_copy)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
assert_equal(resids, resid_copy)
ar = ARX(self.y, lags=5)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
ar = ARX(self.y, lags=5, hold_back=100)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
vol = res.conditional_volatility
vol_copy = vol.copy()
vol_copy[:100] = np.nan
vol_copy[500:] = np.nan
assert_equal(vol, vol_copy)
assert_equal(self.y.shape[0], vol.shape[0])
ar = ARX(self.y, lags=5)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:5] = np.nan
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
def test_arch_arx(self):
np.random.seed(12345)
x = np.random.randn(500, 3)
y = x.sum(1) + 3 * np.random.randn(500)
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series), True
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
am = ARX(y=y, lags=2, x=x)
res = am.fit(disp=DISPLAY)
summ = res.summary().as_text()
repr = res.__repr__()
assert str(hex(id(res))) in repr
assert summ[:10] == repr[:10]
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'y[1]', 'y[2]', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
x = pd.DataFrame(x, columns=['x0', 'x1', 'x2'])
y = pd.Series(y, name='y')
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
def test_ar(self):
ar = ARX(self.y, lags=3)
params = np.array([1.0, 0.4, 0.3, 0.2, 1.0])
data = ar.simulate(params, self.T)
assert_equal(self.y, ar.y)
bounds = ar.bounds()
for b in bounds:
assert_equal(b[0], -np.inf)
assert_equal(b[1], np.inf)
assert_equal(len(bounds), 4)
assert_equal(ar.num_params, 4)
assert_true(ar.constant)
a, b = ar.constraints()
assert_equal(a, np.empty((0, 4)))
assert_equal(b, np.empty(0))
res = ar.fit()
nobs = 1000 - 3
rhs = np.ones((nobs, 4))
y = self.y
lhs = y[3:1000]
for i in range(3, 1000):
rhs[i - 3, 1] = y[i - 1]
rhs[i - 3, 2] = y[i - 2]
rhs[i - 3, 3] = y[i - 3]
params = np.linalg.pinv(rhs).dot(lhs)
assert_almost_equal(params, res.params[:-1])
forecasts = res.forecast(horizon=5)
direct = pd.DataFrame(index=np.arange(y.shape[0]),
columns=['h.' + str(i + 1) for i in range(5)],
dtype=np.float64)
params = res.params.iloc[:-1]
for i in range(2, y.shape[0]):
fcast = np.zeros(y.shape[0] + 5)
fcast[:y.shape[0]] = y.copy()
for h in range(1, 6):
reg = np.array(
[1.0, fcast[i + h - 1], fcast[i + h - 2], fcast[i + h - 3]])
fcast[i + h] = reg.dot(params)
direct.iloc[i, :] = fcast[i + 1:i + 6]
assert_frame_equal(direct, forecasts)
assert_equal(ar.first_obs, 3)
assert_equal(ar.last_obs, 1000)
assert_equal(ar.hold_back, None)
assert_equal(ar.lags, np.array([[0, 1, 2], [1, 2, 3]]))
assert_equal(ar.nobs, 997)
assert_equal(ar.name, 'AR')
assert_equal(ar.use_rotated, False)
ar.__repr__()
ar._repr_html_()
ar = ARX(self.y_df, lags=5)
ar.__repr__()
ar = ARX(self.y_series, lags=5)
ar.__repr__()
res = ar.fit()
assert_true(isinstance(res.resid, pd.Series))
assert_true(isinstance(res.conditional_volatility, pd.Series))
# Smoke tests
summ = ar.fit().summary()
ar = ARX(self.y, lags=1, volatility=GARCH(), distribution=StudentsT())
res = ar.fit(update_freq=5, cov_type='mle')
res.param_cov
res.plot()
res.plot(annualize='D')
res.plot(annualize='W')
res.plot(annualize='M')
assert_raises(ValueError, res.plot, annualize='unknown')
res.plot(scale=360)
res.hedgehog_plot()
def test_first_last_obs(self):
ar = ARX(self.y, lags=5, hold_back=100)
res = ar.fit(update_freq=0, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
assert_equal(resids, resid_copy)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
assert_equal(resids, resid_copy)
ar = ARX(self.y, lags=5)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
ar = ARX(self.y, lags=5, hold_back=100)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:100] = np.nan
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
vol = res.conditional_volatility
vol_copy = vol.copy()
vol_copy[:100] = np.nan
vol_copy[500:] = np.nan
assert_equal(vol, vol_copy)
assert_equal(self.y.shape[0], vol.shape[0])
ar = ARX(self.y, lags=5)
ar.volatility = GARCH()
res = ar.fit(update_freq=0, last_obs=500, disp=DISPLAY)
resids = res.resid
resid_copy = resids.copy()
resid_copy[:5] = np.nan
resid_copy[500:] = np.nan
assert_equal(resids, resid_copy)
def test_arch_arx(self):
self.rng.seed(12345)
x = self.rng.randn(500, 3)
y = x.sum(1) + 3 * self.rng.standard_normal(500)
am = ARX(y=y, x=x)
res = am.fit(disp=DISPLAY)
res.summary()
assert isinstance(res.optimization_result, OptimizeResult)
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp=DISPLAY)
assert isinstance(results.pvalues, pd.Series)
assert_equal(
list(results.pvalues.index),
["Const", "x0", "x1", "x2", "omega", "alpha[1]", "alpha[2]"],
)
am = ARX(y=y, lags=2, x=x)
res = am.fit(disp=DISPLAY)
summ = res.summary().as_text()
res_repr = res.__repr__()
assert str(hex(id(res))) in res_repr
assert summ[:10] == res_repr[:10]
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp=DISPLAY)
assert isinstance(results.pvalues, pd.Series)
assert_equal(
list(results.pvalues.index),
[
"Const",
"y[1]",
"y[2]",
"x0",
"x1",
"x2",
"omega",
"alpha[1]",
"alpha[2]",
],
)
x = pd.DataFrame(x, columns=["x0", "x1", "x2"])
y = pd.Series(y, name="y")
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp=DISPLAY)
assert isinstance(results.pvalues, pd.Series)
assert_equal(
list(results.pvalues.index),
["Const", "x0", "x1", "x2", "omega", "alpha[1]", "alpha[2]"],
)
def test_arch_arx(self):
np.random.seed(12345)
x = np.random.randn(500, 3)
y = x.sum(1) + 3 * np.random.randn(500)
am = ARX(y=y, x=x)
am.fit().summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert_true(isinstance(results.pvalues, pd.Series), True)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
am = ARX(y=y, lags=2, x=x)
am.fit().summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert_true(isinstance(results.pvalues, pd.Series), True)
assert_equal(list(results.pvalues.index),
['Const', 'y[1]', 'y[2]', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
x = pd.DataFrame(x, columns=['x0', 'x1', 'x2'])
y = pd.Series(y, name='y')
am = ARX(y=y, x=x)
am.fit().summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert_true(isinstance(results.pvalues, pd.Series), True)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
def test_arch_arx(self):
np.random.seed(12345)
x = np.random.randn(500, 3)
y = x.sum(1) + 3 * np.random.randn(500)
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series), True
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
am = ARX(y=y, lags=2, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'y[1]', 'y[2]', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
x = pd.DataFrame(x, columns=['x0', 'x1', 'x2'])
y = pd.Series(y, name='y')
am = ARX(y=y, x=x)
am.fit(disp=DISPLAY).summary()
am.volatility = ARCH(p=2)
results = am.fit(update_freq=0, disp='off')
assert isinstance(results.pvalues, pd.Series)
assert_equal(list(results.pvalues.index),
['Const', 'x0', 'x1', 'x2',
'omega', 'alpha[1]', 'alpha[2]'])
