def test_predict_is_intervals_bbvi():
model = pf.GARCH(data=data, q=1, p=1)
x = model.fit('BBVI', iterations=100)
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values >= predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values >= predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values >= predictions['1% Prediction Interval'].values))
def test_predict_is_intervals_mh():
model = pf.GARCH(data=data, q=1, p=1)
x = model.fit('M-H', nsims=400)
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values >= predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values >= predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values >= predictions['1% Prediction Interval'].values))
def GarchVol(ret):
model = pf.GARCH(ret, p=1, q=1)
x = model.fit()
assert (len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert (len(lvs[np.isnan(lvs)]) == 0)
return x, model
def test_predict_is_intervals():
model = pf.GARCH(data=data, q=2, p=2)
x = model.fit()
predictions = model.predict_is(h=10, intervals=True)
assert(np.all(predictions['99% Prediction Interval'].values >= predictions['95% Prediction Interval'].values))
assert(np.all(predictions['95% Prediction Interval'].values >= predictions['5% Prediction Interval'].values))
assert(np.all(predictions['5% Prediction Interval'].values >= predictions['1% Prediction Interval'].values))
def roll_prediction_egarch(return_tr, vol_tr, return_ts, vol_ts,
training_order, method):
roll_x = return_tr
vol_hat = []
for i in range(len(vol_ts)):
print 'now processing', i
tmp_x = roll_x[-training_order:]
if method == 'garch':
model = pf.GARCH(tmp_x, p=1, q=1)
x = model.fit()
elif method == 'egarch':
model = pf.EGARCH(tmp_x, p=1, q=1)
x = model.fit()
vol_hat.append(np.asarray(model.predict(1))[0][0])
roll_x = np.concatenate((roll_x, return_ts[i:i + 1]))
# return rooted mse
return vol_hat, sqrt(
mean((vol_ts - np.asarray(vol_hat)) * (vol_ts - np.asarray(vol_hat))))
def test_predict_is_nans():
model = pf.GARCH(data=data, q=2, p=2)
x = model.fit()
x.summary()
assert (len(
model.predict_is(h=5).values[np.isnan(
model.predict_is(h=5).values)]) == 0)
def _fit_model(self):
sql_string = "SELECT * FROM underlying_data WHERE symbol='{0}' " \
"AND bar_length='1440' AND data_type='TRADES' ORDER BY date".format(self.symbol)
data = self._read_sql_query(sql_string)
returns = self._calc_reg_returns(data['close'])
model = pf.GARCH(returns, p=1, q=1)
model.fit()
return model
def main():
symbols = import_from_csv()
print symbols
with open(
'simputsW.csv',
'wb',
) as currdata:
writer = csv.writer(currdata, delimiter=',')
writer.writerow([
"Symbol", "Tag", "Strike", "Price", "Barone-Adesi Whaley",
"Bjerksund Stensland", "Cox-Ross-Rubenstein", "Jarrow-Rudd",
"Equal Probabilities", "Trigeorgis", "Tian", "Leisen-Reimer"
])
for i in symbols:
oc = OptionChain('NASDAQ:' + i, {
"expy": "2016",
"expm": "06",
"expd": "10"
})
underlying = float(getQuotes(i)[0]['LastTradeWithCurrency'])
stock = DataReader(i, 'yahoo', datetime(2014, 1, 1),
datetime(2016, 6, 1))
returns = pd.DataFrame(np.diff(np.log(stock['Adj Close'].values)))
model = pf.GARCH(abs(returns), p=1, q=1)
x = model.fit()
vol = float(
model.predict(h=7)['0'].values.tolist()[-1]) * float(100)
for j in oc.puts:
strike = float(j['strike'])
if (str(j['p']) != '-'):
opttype = Option.Put
todaysDate = Date(4, June, 2016)
expiryDate = Date(10, June, 2016)
print('-' * 32)
print(i)
print(j['s'])
print(str(j['strike']))
print(str(j['p']))
results = EstimateOption(todaysDate, expiryDate, vol,
opttype, underlying, strike)
writer.writerow(
[str(i),
str(j['s']),
str(j['strike']),
str(j['p'])] + results)
def oneshot_prediction_egarch(return_tr, vol_tr, return_ts, vol_ts, method):
if method == 'garch1':
model = pf.GARCH(return_tr, p=1, q=1)
x = model.fit()
tr_sigma2, _, ___ = model._model(model.latent_variables.get_z_values())
vol_tr_hat = tr_sigma2**0.5
elif method == 'egarch1':
model = pf.EGARCH(return_tr, p=1, q=1)
x = model.fit()
tr_sigma2, _, ___ = model._model(model.latent_variables.get_z_values())
vol_tr_hat = np.exp(tr_sigma2 / 2.0)
tmp_pre = np.asarray(model.predict(len(vol_ts)))
vol_ts_hat = []
for i in tmp_pre:
vol_ts_hat.append(i[0])
return vol_ts_hat, vol_tr_hat, sqrt(mean((vol_ts - np.asarray(vol_ts_hat))*(vol_ts - np.asarray(vol_ts_hat)))), \
sqrt(mean((vol_tr[1:] - np.asarray(vol_tr_hat))*(vol_tr[1:] - np.asarray(vol_tr_hat))))
garch_model.getMu(),
)
print('predict value:', garch_model.predict(sim_data))
# igarch model
igarch_model = IGARCHModel(1, 1, _use_mu=True)
start_time = time.time()
igarch_model.fit(sim_data)
print('fitting time:', time.time() - start_time)
print(
igarch_model.getAlphas(),
igarch_model.getBetas(),
igarch_model.getConst(),
igarch_model.getMu(),
)
print('predict value:', igarch_model.predict(sim_data))
sim_line, = plt.plot(np.sqrt(garch_sim.var[2:]), label='simulation')
garch_line, = plt.plot(garch_model.getVolatility(), label='garch')
igarch_line, = plt.plot(igarch_model.getVolatility(), label='igarch')
plt.legend(handles=[sim_line, garch_line, igarch_line])
plt.show()
# pyflux's garch model
pf_model = pf.GARCH(sim_data, 1, 1)
start_time = time.time()
pf_ret = pf_model.fit("MLE")
print('fitting time:', time.time() - start_time)
pf_ret.summary()
print(pf_model.predict())
import numpy as np
import pyflux as pf
import sys
import pandas as pd
from pandas_datareader.data import DataReader
jpm = DataReader('GOOG', 'google')
returns = pd.DataFrame(np.diff(np.log(jpm['Close'].values)))
returns.index = jpm.index.values[1:jpm.index.values.shape[0]]
returns.columns = ['Google Returns']
model = pf.GARCH(returns, p=1, q=1)
x = model.fit()
#x.summary()
print np.sqrt(np.abs(returns.head(int(sys.argv[1])))) * 100
#model.predict(h=10)
def test_predict_is_nonconstant():
model = pf.GARCH(data=data, p=2, q=2)
x = model.fit()
predictions = model.predict_is(h=5, intervals=False)
assert(not np.all(predictions.values==predictions.values[0]))
def test_predict_is_length():
model = pf.GARCH(data=data, p=2, q=2)
x = model.fit()
assert(model.predict_is(h=5).shape[0] == 5)
def test_pml():
model = pf.GARCH(data=data, p=1, q=1)
x = model.fit('PML')
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_bbvi_mini_batch_elbo():
model = pf.GARCH(data=data, p=1, q=1)
x = model.fit('BBVI',iterations=100, map_start=False, mini_batch=32, record_elbo=True)
assert(x.elbo_records[-1]>x.elbo_records[0])
def test_bbvi_mini_batch():
model = pf.GARCH(data=data, p=1, q=1)
x = model.fit('BBVI',iterations=100, mini_batch=32)
assert(len(model.latent_variables.z_list) == 4)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
def test_ppc():
model = pf.GARCH(data=data, q=2, p=2)
x = model.fit('BBVI', iterations=100)
p_value = model.ppc()
assert(0.0 <= p_value <= 1.0)
def test_sample_model():
model = pf.GARCH(data=data, q=2, p=2)
x = model.fit('BBVI', iterations=100)
sample = model.sample(nsims=100)
assert(sample.shape[0]==100)
assert(sample.shape[1]==len(data)-2)
import logging
import pyflux as pf
from TorchTSA.model import ARCHModel
from TorchTSA.simulate import ARCHSim
logging.basicConfig(level=logging.INFO)
arch_sim = ARCHSim((0.6, 0.1), _const=0.1, _mu=0.0)
sim_data = arch_sim.sample_n(1000)
arch_model = ARCHModel(2, _use_mu=True)
arch_model.fit(sim_data)
print(
arch_model.getAlphas(),
arch_model.getConst(),
arch_model.getMu(),
)
print('predict value:', arch_model.predict(sim_data))
pf_model = pf.GARCH(sim_data, 0, 2)
pf_ret = pf_model.fit("MLE")
pf_ret.summary()
print(pf_model.predict())
1 - Maximum_Weight / 100.0)
Instrument_Data['AR_Comb_PL'] = Instrument_Data.apply(
lambda x: x["PUT_" + file]
if x["AR_Comb_Forecast"] > 0.1 else x["CALL_" + file]
if x["AR_Comb_Forecast"] < -0.1 else 0,
axis=1)
Instrument_Data['Total_AR_Comb_PL'] = list(
accumu(Instrument_Data['AR_Comb_PL'].tolist()))
print "AR Model" + "\tOptimimal Weight: " + str(
Maximum_Weight) + "\tMax Equity: " + str(Maximum_EQ)
#########################################################################
############################# GARCH MODEL #############################
logging.info('\t' + str(datetime.now()) + ' Calculating GARCH Model...')
model1 = pf.GARCH(ts_ret2[:len(ts_ret2) / 2 + 1], p=1, q=1)
results_GR = model1.fit()
results_GR.summary()
# Plot Fit in In-Sample Fitting
model1.plot_fit()
GARCH_Pred = np.sqrt(results_GR.signal).tolist()
for i in range(len(ts_ret2) / 2 - 1, len(ts_ret2) - 1):
# Fit Model again and make prediction
model2 = pf.GARCH(ts_ret2[:i], p=1, q=1)
results_GR2 = model2.fit()
#print model2.predict(h=1)
def test_no_terms():
model = pf.GARCH(data=data, p=0, q=0)
x = model.fit()
assert(len(model.latent_variables.z_list) == 2)
lvs = np.array([i.value for i in model.latent_variables.z_list])
assert(len(lvs[np.isnan(lvs)]) == 0)
if arima_results_bic < arima_bic:
arima_p = p
arima_q = q
arima_model = arima_model_middle
arima_bic = arima_results_bic
arima_diff = diff_num
if arima_model == None:
predict_arima_pf = np.zeros(len(predict_date), )
else:
predict_arima_pf = arima_model.predict(h=len(predict_date))
arima_list.append([k, arima_p, arima_q, arima_diff, 'pf'])
predict_arima = np.zeros(len(predict_date), )
data_arima_origin = np.array(
map((lambda x: x[0]), np.array(data_arima_origin)))
GARCH_model = pf.GARCH(data=np.array(data_arima_origin), p=2, q=2)
GARCH_model.fit('MLE')
# model.plot_fit()
predict_garch = GARCH_model.predict(90)
predict_arima_origin = copy.deepcopy(predict_arima)
for i in xrange(len(predict_date)):
predict_arima[i] = float(predict_arima[i] *
(1 + bodong_small_final[i]) *
(1 * (1 + bodong_big_final[i])))
if predict_arima[i] < 0:
predict_arima[i] = int(0)
if arima_linear_mix == 1:
arima_linear_weight = [1, 9]
for i in xrange(len(predict_date)):
a_returns.head()
# Step 1: Visualization
# creating a plot of Adobe Returns
fig, axs = plt.subplots(2, 1, figsize=(12, 12))
axs[0].plot(a_prices)
axs[0].set_title("ADBE price since Dave Joined")
axs[1].plot(a_returns)
axs[1].set_title("ADBE returns since Dave Joined")
plt.show()
pf.acf_plot(a_returns.values.T[0], max_lag=260)
pf.acf_plot(np.square(a_returns.values.T[0]), max_lag=260)
# Step 2: Propose a model
my_model = pf.GARCH(p=1, q=1, data=a_returns)
print(my_model.latent_variables)
#Step 3: Inference
# Using Metropolis-Hastings for approximate inference on GARCH mode
result = my_model.fit('M-H', nsims=20000)
# Ploting latent variabes alpha and beta
my_model.plot_z([1, 2])
# Step 4: Evaluate Model Fit
# Plotting the series versus its predicted values
# Can check out of sample performance
# plot the fit of the GARCH model and observe that it is picking
# up volatility clustering in the series
my_model.plot_fit(figsize=(15, 5))
#errors
error_var1 = mean_absolute_error(original_values[:,0],allpredicted_values[:,0])
error_var2 = r2_score(original_values[:,0],allpredicted_values[:,0])
#GARCH
data = pd.DataFrame({'pm25data':np.diff(my_data[:,4][:12000])})
model = pf.GARCH(data=data, p=1, q=1, target='pm25data')
x = model.fit("MLE")
model.plot_fit()
stop = 15000
start = 14900
interval = 20
nmbr_predictions = 2
allpredicted_values = np.array([])
original_values = np.array([])
for i in range(start,stop,interval):
i = i+nmbr_predictions
data = pd.DataFrame({'pm25data':np.diff(my_data[:,4][:i])})
model = pf.GARCH(data=data, p=0, q=1, target='pm25data')
x = model.fit("MLE")
