def load_prices(symbols, start_date, end_date):
prices = dl.load_price_data(DATA_DIR, symbols)
df = None
for key, value in prices.iteritems():
dataset = value[start_date:end_date]
dataset.rename(columns={PRICE: key}, inplace=True)
if df is None:
df = pd.DataFrame(dataset[key])
else:
df = df.join(dataset[key])
return df
def main():
run_date = dt.datetime(2014, 9, 19)
run_date_str = run_date.strftime('%Y%m%d')
# symbols = \
# data_loader.load_symbol_list(
# '/Users/Conor/code/python/conor10.tickdata/symbols/'
# 'SP500/20140907/symbols.txt')
symbols = ['AAPL']
all_options_prices = data_loader.load_option_data(
'SP500',
'/Users/Conor/code/python/conor10.tickdata/chains',
symbols,
start_date=run_date_str,
end_date=run_date_str)
all_stock_prices = data_loader.load_price_data(
'/Users/Conor/code/python/conor10.tickdata/daily_prices/SP500',
symbols)
for symbol in symbols:
stock_price = all_stock_prices[symbol]
underlying_price = \
stock_price['Adj Close'][[run_date]].values[0]
print(underlying_price)
stock_price['Adj Returns'] = \
utils.calculate_returns(stock_price['Adj Close'].values)
start_date = run_date - dt.timedelta(31)
sigma = stock_price[start_date:run_date]['Adj Returns'].std(
) * math.sqrt(252.0)
option_prices = all_options_prices[symbol]
for capture_date in option_prices.keys():
expiries = option_prices[capture_date]
for expiry in expiries.keys():
prices = expiries[expiry]
puts = prices[OptionType.PUT]
print(expiry)
# print(puts)
dt_expiry = dt.datetime.strptime(expiry, '%Y%m%d')
days_in_year = 366 if calendar.isleap(dt_expiry.year) else 365
days_to_expiry = dt_expiry - run_date
delta = days_to_expiry.days / days_in_year
for strike in puts.index:
last_price_str = puts.ix[strike]['LAST_PRICE']
if last_price_str == '-':
continue
last_price = float(last_price_str)
price = option.calc_option_price(OptionType.PUT,
strike,
underlying_price,
sigma,
delta,
risk_free_rate=0.01)
implied_volatility = option.implied_volatility(
OptionType.PUT, strike, underlying_price, last_price,
delta)
print('Strike: {}, calc price: {}, actual {}'.format(
strike, price, last_price))
print('Sigma: {}, implied sigma: {}'.format(
sigma, implied_volatility))
def main():
run_date = dt.datetime(2014, 9, 19)
run_date_str = run_date.strftime('%Y%m%d')
# symbols = \
# data_loader.load_symbol_list(
# '/Users/Conor/code/python/conor10.tickdata/symbols/'
# 'SP500/20140907/symbols.txt')
symbols = ['AAPL']
all_options_prices = data_loader.load_option_data(
'SP500',
'/Users/Conor/code/python/conor10.tickdata/chains',
symbols,
start_date=run_date_str,
end_date=run_date_str)
all_stock_prices = data_loader.load_price_data(
'/Users/Conor/code/python/conor10.tickdata/daily_prices/SP500',
symbols)
for symbol in symbols:
# Get all puts
# if put is OTM, predict probability it will be ITM at expiry
stock_prices = all_stock_prices[symbol]
underlying_price = \
stock_prices['Close'][[run_date]].values[0]
print(underlying_price)
stock_prices['Adj Returns'] = \
utils.calculate_returns(stock_prices['Adj Close'].values)
option_prices = all_options_prices[symbol]
for capture_date in option_prices.keys():
expiries = option_prices[capture_date]
for expiry in sorted(expiries.keys()):
prices = expiries[expiry]
puts = prices[OptionType.PUT]
print(expiry)
dt_expiry = dt.datetime.strptime(expiry, '%Y%m%d')
# TODO: Calculate the exact value -
# TODO: there's 9 trading holidays on NASDAQ in 2014
days_in_year = np.busday_count('2014', '2015') - 9
days_to_expiry = utils.work_day_count(run_date, dt_expiry)
# TODO: Need to calculate trading days to expiry
# TODO: workalendar may be useful
#TODO Rename
duration = days_to_expiry / days_in_year
# TODO: Make model more sophisticated for sigma
# lookback_period = days_to_expiry
lookback_period = days_in_year
sigma = calc_sigma(stock_prices, lookback_period, run_date,
days_in_year)
itm_probability = price_series.calc_itm_probability(
puts.index, underlying_price, sigma, days_to_expiry, 10000,
OptionType.PUT)
# print(itm_probability)
# We're only interested in strikes that are OTM to start with
otm_probabilities = itm_probability[np.where(
itm_probability[:, 0] < underlying_price)]
# print(otm_probabilities)
# select all options we have a last price for & assume this
# selling cost
results = []
for strike, probability in otm_probabilities:
last_price_str = puts.ix[strike]['LAST_PRICE']
if last_price_str == '-':
continue
last_price = float(last_price_str)
# print('Strike: {}, P(ITM): {}, Last Price: {}'.format(
# strike, probability, last_price))
results.append([strike, probability, last_price])
data = np.asarray(results).T
# last_price / probability
upside_ratio = data[2] / data[1]
# discard inf values
upside_ratio[np.where(upside_ratio == np.inf)] = 0
upside_ratio[np.where(upside_ratio == np.nan)] = 0
optimal_idx = upside_ratio.argmax()
# print('Optimal option: {}'.format(data[0][optimal_idx]))
optimal = [[data[0][optimal_idx]], [data[1][optimal_idx]],
[data[2][optimal_idx]]]
plot3D(
data[0], data[1], data[2], optimal,
'Date: {}, Underlying: {}, Last price: {}, Expiry: {}'.
format(capture_date, symbol, underlying_price, expiry))
def main():
run_date = dt.datetime(2014, 9, 19)
# symbols = \
# data_loader.load_symbol_list(
# '/Users/Conor/code/python/conor10.tickdata/symbols/'
# 'SP500/20140907/symbols.txt')
symbols = ['AAPL']
all_stock_prices = data_loader.load_price_data(
'/Users/Conor/code/python/conor10.tickdata/daily_prices/SP500',
symbols)
for symbol in symbols:
stock_prices = all_stock_prices[symbol]
underlying_price = \
stock_prices['Close'][[run_date]].values[0]
print(underlying_price)
# TODO: Plot these
# TODO: Fix log return calculations
stock_prices['Adj Returns'] = \
utils.calculate_log_returns(stock_prices['Adj Close'].values)
# extract a training set
training_set = stock_prices['Adj Returns'][-2500:-200].values
test_set = stock_prices['Adj Returns'][-200:].values
sigma = training_set.std()
mu = training_set.mean()
print('training set mu: {}, sigma: {}'.format(mu, sigma))
training_hist, training_edges = np.histogram(training_set, 120)
training_hist = training_hist / float(len(training_set))
training_centres = 0.5 * (training_edges[1:] + training_edges[:-1])
fit_mu, fit_sigma = calc_fit(normal_dist, np.random.rand(2),
training_centres, training_hist)
print('fitted mu: {}, sigma: {}'.format(fit_mu, fit_sigma))
plot_fit(normal_dist, (fit_mu, fit_sigma), training_centres,
training_hist)
# interpolate - how?
fit_nu, fit_mu, fit_sigma = calc_fit(t_dist, np.random.rand(3),
training_centres, training_hist)
print('fitted nu: {}, mu: {}, sigma: {}'.format(
fit_nu, fit_mu, fit_sigma))
plot_fit(t_dist, (fit_nu, fit_mu, fit_sigma), training_centres,
training_hist)
fit_log_mu, fit_log_sigma = calc_fit(log_normal_dist,
np.random.rand(2),
training_centres, training_hist)
print('fitted log mu: {}, log sigma: {}'.format(
fit_log_mu, fit_log_sigma))
plot_fit(log_normal_dist, (fit_log_mu, fit_log_sigma),
training_centres, training_hist)
fit_lambda = calc_fit(exp_weighted_moving_average, np.random.rand(1),
training_centres, training_hist)
print('fitted lambda: {}'.format(fit_lambda))
plot_fit(exp_weighted_moving_average, fit_lambda, training_centres,
training_hist)
def test_load_price_data(self):
price_data = dl.load_price_data(DATA_DIR, self._get_symbol_list())
self.assertEqual(3, len(price_data))
self.assertEqual(pd.DataFrame, type(price_data['TEST']))
self.assertEqual(pd.DataFrame, type(price_data['TEST2']))
self.assertEqual(pd.DataFrame, type(price_data['TEST3']))
def _get_test_data(self):
return dl.load_price_data(DATA_DIR, SYMBOL_LIST)
def _get_price_data(symbols, start_date=None, end_date=None):
symbol_data = data_loader.load_price_data(data_sources.DATA_DIR, symbols)
price_data = PriceData(symbol_data)
return price_data.get_price_data_np(symbols, 'Adj Close', start_date,
end_date)