def test_variance_ratio(self):
vr = VarianceRatio(self.inflation, debiased=False)
y = self.inflation
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / (nq)
num = np.sum((dy2 - 2 * mu) ** 2.0) / (nq * 2)
ratio = num / denom
assert_almost_equal(ratio, vr.vr)
assert 'Variance-Ratio Test' in str(vr)
vr.debiased = True
assert vr.debiased is True
def test_variance_ratio(self):
vr = VarianceRatio(self.inflation, debiased=False)
y = self.inflation
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / (nq)
num = np.sum((dy2 - 2 * mu) ** 2.0) / (nq * 2)
ratio = num / denom
assert_almost_equal(ratio, vr.vr)
assert 'Variance-Ratio Test' in str(vr)
vr.debiased = True
assert vr.debiased is True
def test_variance_ratio(self):
vr = VarianceRatio(self.inflation, debiased=False)
y = self.inflation
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu)**2.0) / nq
num = np.sum((dy2 - 2 * mu)**2.0) / (nq * 2)
ratio = num / denom
assert_almost_equal(ratio, vr.vr)
assert "Variance-Ratio Test" in str(vr)
with pytest.warns(FutureWarning, match="Mutating unit root"):
vr.debiased = True
assert vr.debiased is True
def test_wrong_exceptions_variance_ratio(nobs, trend, overlap, debiased):
y = np.random.standard_normal((nobs,))
try:
vr = VarianceRatio(y, trend=trend, lags=4, overlap=overlap, debiased=debiased)
assert np.isfinite(vr.stat)
except InfeasibleTestException:
pass
def test_variance_ratio_non_robust(self):
vr = VarianceRatio(self.inflation, robust=False, debiased=False)
y = self.inflation
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / nq
num = np.sum((dy2 - 2 * mu) ** 2.0) / (nq * 2)
ratio = num / denom
variance = 3.0 / 2.0
stat = np.sqrt(nq) * (ratio - 1) / np.sqrt(variance)
assert_almost_equal(stat, vr.stat)
orig_stat = vr.stat
vr.robust = True
assert_equal(vr.robust, True)
assert vr.stat != orig_stat
def test_variance_ratio_non_robust(self):
vr = VarianceRatio(self.inflation, robust=False, debiased=False)
y = self.inflation
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / nq
num = np.sum((dy2 - 2 * mu) ** 2.0) / (nq * 2)
ratio = num / denom
variance = 3.0 / 2.0
stat = np.sqrt(nq) * (ratio - 1) / np.sqrt(variance)
assert_almost_equal(stat, vr.stat)
orig_stat = vr.stat
vr.robust = True
assert_equal(vr.robust, True)
assert vr.stat != orig_stat
def VarianceRatioTest(data, printResults=True, trend=None, lags=None):
options_Trend = trend if trend != None else {'nc','c'}
options_Lags = lags if lags != None else {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}
results = dict()
for column in data.columns:
print("Variance Ratio test for column: " + column)
results_Trend = dict()
for option_Trend in options_Trend:
results_Lag = dict()
for option_Lag in options_Lags:
result = VarianceRatio(data[column].dropna(), trend=option_Trend, lags=option_Lag)
if printResults:
result.summary()
results_Lag[option_Lag] = result
results_Trend[option_Trend] = results_Lag
results[column] = results_Trend
return results
def generate_stationarity_dataframe(potential_pairs_index, cv_spreads_train):
adfuller_t = []
adfuller_p = []
kpss_t = []
kpss_p = []
pp_t = []
pp_p = []
vr_t = []
vr_p = []
warnings.filterwarnings('ignore')
for i, pair in enumerate(potential_pairs_index):
temp_spread = cv_spreads_train[pair]
temp_adfuller = ts.adfuller(temp_spread)
temp_adfuller_t = temp_adfuller[0]
temp_adfuller_p = temp_adfuller[1]
temp_kpss = ts.kpss(temp_spread)
temp_kpss_t = temp_kpss[0]
temp_kpss_p = temp_kpss[1]
temp_pp = PhillipsPerron(temp_spread)
temp_pp_t = temp_pp.stat
temp_pp_p = temp_pp.pvalue
temp_vr = VarianceRatio(temp_spread)
temp_vr_t = temp_vr.stat
temp_vr_p = temp_vr.pvalue
adfuller_t.append(temp_adfuller_t)
adfuller_p.append(temp_adfuller_p)
kpss_t.append(temp_kpss_t)
kpss_p.append(temp_kpss_p)
pp_t.append(temp_pp_t)
pp_p.append(temp_pp_p)
vr_t.append(temp_vr_t)
vr_p.append(temp_vr_p)
cv_stationary_tests = pd.DataFrame(
{
'adf_t_stat': adfuller_t,
'adf_p_value': adfuller_p,
'kpss_t_stat': kpss_t,
'kpss_p_value': kpss_p,
'pp_t_stat': pp_t,
'pp_p_value': pp_p,
'vr_t_stat': vr_t,
'vr_p_value': vr_p
},
index=potential_pairs_index)
return cv_stationary_tests
def test_variance_ratio_no_constant(self):
y = self.rng.randn(100)
vr = VarianceRatio(y, trend='nc', debiased=False)
dy = np.diff(y)
mu = 0.0
dy2 = y[2:] - y[:-2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / nq
num = np.sum((dy2 - 2 * mu) ** 2.0) / (nq * 2)
ratio = num / denom
assert_almost_equal(ratio, vr.vr)
assert_equal(vr.debiased, False)
def test_variance_ratio_no_overlap(self):
vr = VarianceRatio(self.inflation, overlap=False)
with warnings.catch_warnings(record=True) as w:
computed_value = vr.vr
assert_equal(len(w), 1)
y = self.inflation
# Adjust due ot sample size
y = y[:-1]
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2::2] - y[:-2:2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / nq
num = np.sum((dy2 - 2 * mu) ** 2.0) / nq
ratio = num / denom
assert_equal(ratio, computed_value)
vr.overlap = True
assert_equal(vr.overlap, True)
vr2 = VarianceRatio(self.inflation)
assert_almost_equal(vr.stat, vr2.stat)
def test_variance_ratio_no_overlap(self):
vr = VarianceRatio(self.inflation, overlap=False)
with warnings.catch_warnings(record=True) as w:
computed_value = vr.vr
assert_equal(len(w), 1)
y = self.inflation
# Adjust due ot sample size
y = y[:-1]
dy = np.diff(y)
mu = dy.mean()
dy2 = y[2::2] - y[:-2:2]
nq = dy.shape[0]
denom = np.sum((dy - mu) ** 2.0) / nq
num = np.sum((dy2 - 2 * mu) ** 2.0) / nq
ratio = num / denom
assert_equal(ratio, computed_value)
vr.overlap = True
assert_equal(vr.overlap, True)
vr2 = VarianceRatio(self.inflation)
assert_almost_equal(vr.stat, vr2.stat)
def perform_variance_ratio_test(series, lag=2, notes=False):
"""
The null hypothesis of a VR is that the process is a random walk, possibly plus drift.
Rejection of the null with a positive test statistic indicates the presence of positive
serial correlation in the time series.
Return p-value. Less than 0.05, reject null hypothesis. It is not a random walk.
"""
result = VarianceRatio(series, lag).pvalue
if notes:
print('Variance Ratio: {:.3f}'.format(result))
if result < 0.05:
print('Not a random walk')
else:
print('Random Walk')
else:
return result, result < 0.05
def test_variance_ratio_generic(self):
# TODO: Currently not a test, just makes sure code runs at all
vr = VarianceRatio(self.inflation, lags=24)
assert isinstance(vr, VarianceRatio)
def test_variance_ratio_invalid_lags(self):
y = self.inflation
with pytest.raises(ValueError):
VarianceRatio(y, lags=1)
def test_mean_reversion(times_series):
print(VarianceRatio(times_series))
print(VarianceRatio(times_series, lags=4))
print(VarianceRatio(times_series, lags=8))
print(VarianceRatio(times_series, lags=16))
print(hurst(times_series))
import statsmodels.tsa.stattools as st
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
df_caus = pd.read_csv('USDCAD.csv')
plt.hold(False)
df_caus.y.plot()
#plt.show()
print st.adfuller(df_caus.y, maxlag=1)
import hurst as h
print 'H doviz kuru', h.hurst(df_caus.y)
from arch.unitroot import VarianceRatio
vr = VarianceRatio(np.log(df_caus.y))
print(vr.summary().as_text())
df_caus['ylag'] = df_caus['y'].shift(1)
df_caus['deltaY'] = df_caus['y'] - df_caus['ylag']
import statsmodels.formula.api as smf
results = smf.ols('deltaY ~ ylag', data=df_caus).fit()
lam = results.params['ylag']
print lam
halflife = -np.log(2) / lam
print halflife, 'days'
#plt.savefig(files.image_path + '\LH_close_vol_return.png')
data = lh['Close'].resample('M').mean() # resample daily data to monthly data
data = data['1992':'2004']
data = np.log(data / data.shift(1)).dropna() * 100 # d 1
adf = ADF(data)
print(adf.summary().as_text())
kpss = KPSS(data)
print(kpss.summary().as_text())
dfgls = DFGLS(data)
print(dfgls.summary().as_text())
pp = PhillipsPerron(data)
print(pp.summary().as_text())
za = ZivotAndrews(data)
print(za.summary().as_text())
vr = VarianceRatio(data, 12)
print(vr.summary().as_text())
print(data.describe())
print('Lean Hogs Future skewness is {}'.format(data.skew(axis=0)))
print('Lean Hogs Future kurtosis is {}'.format(data.kurtosis(axis=0)))
import matplotlib.gridspec as gridspec
import statsmodels.api as sm
import scipy.stats as stats
import seaborn as sns
# Plot figure with subplots of different sizes
fig = plt.figure(1)
# set up subplot grid
gridspec.GridSpec(2, 2)
import statsmodels.tsa.stattools as st
import matplotlib.pylab as plt
import numpy as np
import pandas as pd
df_caus = pd.read_csv('USDCAD.csv')
plt.hold(False)
df_caus.y.plot()
#plt.show()
print st.adfuller(df_caus.y,maxlag=1)
import hurst as h
print 'H doviz kuru', h.hurst(df_caus.y)
from arch.unitroot import VarianceRatio
vr = VarianceRatio(np.log(df_caus.y))
print(vr.summary().as_text())
df_caus['ylag'] = df_caus['y'].shift(1)
df_caus['deltaY'] = df_caus['y'] - df_caus['ylag']
import statsmodels.formula.api as smf
results = smf.ols('deltaY ~ ylag', data=df_caus).fit()
lam = results.params['ylag']
print lam
halflife=-np.log(2)/lam
print halflife, 'days'
plt.title('1986–2018 Lean Hogs Future return frequency')
plt.xlabel('Possible range of data values')
# Pull up summary statistics
print(lh.describe())
adf = ADF(lh['Close'])
print(adf.summary().as_text())
kpss = KPSS(lh['Close'])
print(kpss.summary().as_text())
dfgls = DFGLS(lh['Close'])
print(dfgls.summary().as_text())
pp = PhillipsPerron(lh['Close'])
print(pp.summary().as_text())
za = ZivotAndrews(lh['Close'])
print(za.summary().as_text())
vr = VarianceRatio(lh['Close'], 12)
print(vr.summary().as_text())
from arch import arch_model
X = 100 * lh
import datetime as dt
am = arch_model(X, p=4, o=0, q=0, vol='Garch', dist='StudentsT')
res = am.fit(last_obs=dt.datetime(2003, 12, 31))
forecasts = res.forecast(horizon=1, start='2004-1-1')
cond_mean = forecasts.mean['2004':]
cond_var = forecasts.variance['2004':] / 31
print(res.summary())
# acf and pacf test
def calculate_variance_ratio(dfseries):
"""Calculates the variance ratio to Asses that the Hurst exponent is correctly calculated"""
log_series = np.log2(dfseries)
vratio = VarianceRatio(log_series)
print(vratio)
return vratio
