def main(argv):
l_event_strategies = []
l_event_strategies.append(es.UnderThreshold('sp5002012', 'actual_close', 9))
#l_event_strategies.append(es.RelativeStrength('sp5002008', 'close', -5, 'SPY', 2))
#l_event_strategies.append(es.DailyChange('sp5002008', 'close', -10, '%'))
#l_event_strategies.append(es.RelativeStrengthWithVolume('sp5002008', 'close', -5, 'SPY', 2))
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
print 'AnalysisEngine : Events to Analyze:'
i = 0
for e in l_event_strategies:
i += 1
print 'AnalysisEngine : %00d - %s' % (i, e.getName())
print
print 'AnalysisEngine : Profiling Events'
ep.profile_events(dt_start, dt_end, l_event_strategies)
print
print 'AnalysisEngine : Simulating Orders'
ms.simulate_orders(50000, l_event_strategies)
print
print 'AnalysisEngine : Analyzing Results'
pa.analize_results('$SPX', l_event_strategies, dt_start, dt_end)
def main_optimal():
# Set-up initial parameters for simulation
symbol = "JPM"
sd = dt.datetime(2008, 1, 2)
ed = dt.datetime(2009, 12, 31)
sv = 100000
commission = 0
impact = 0
# Calculate optimal portfolio values
optimal_trades = testPolicy(symbol=symbol, sd=sd, ed=ed, sv=sv)
optimal_trades = process_trades_df(optimal_trades, "JPM")
optimal_port_vals = ms.compute_portvals(optimal_trades,
start_val=sv,
commission=commission,
impact=impact)
optimal_port_vals = optimal_port_vals / optimal_port_vals.iloc[0, :]
# Calculate benchmark portfolio values
benchmark_trades = pd.DataFrame(data=[["JPM", "BUY", 1000]],
index=[sd, ed],
columns=["Symbol", "Order", "Shares"])
benchmark_port_vals = ms.compute_portvals(benchmark_trades,
start_val=sv,
commission=commission,
impact=impact)
benchmark_port_vals = benchmark_port_vals / benchmark_port_vals.iloc[0, :]
# Plot optimal strategy
plt.plot(benchmark_port_vals, color='g', linewidth=0.7)
plt.plot(optimal_port_vals, color='r', linewidth=0.7)
plt.legend(["Benchmark", "Optimal"])
plt.title("Portfolio Values: Benchmark vs. Optimal", fontsize=10)
plt.ylabel("Normalized Values", fontsize=8)
plt.xlabel("Date Range", fontsize=8)
plt.savefig('Optimal.png')
ocr, oadr, osddr, osr = id.calculate_portfolio_metrics(optimal_port_vals)
bcr, badr, bsddr, bsr = id.calculate_portfolio_metrics(benchmark_port_vals)
print("Optimal: ", ocr, oadr, osddr, osr)
print("Benchmark:", bcr, badr, bsddr, bsr)
def main(argv):
# parameters
s_list_name = "sp5002012"
dt_start = dt.datetime(2008, 1, 1)
dt_end = dt.datetime(2009, 12, 31)
s_bench_sym = "SPY"
i_initial_cash = 100000
print "TechInv : Bollinger Event Study"
# read market data
dataobj = da.DataAccess("Yahoo")
ls_symbols = dataobj.get_symbols_from_list(s_list_name)
ls_symbols.append(s_bench_sym)
d_data = get_symbol_data(dataobj, ls_symbols, dt_start, dt_end)
# create the object that implements the strategy
event_strategy = es.BollingerRelWeakness(s_list_name, d_data, i_initial_cash, 20)
df_events, i_event_counter = event_strategy.find_events(ls_symbols, "close", 2.0, s_bench_sym, 1.3)
print "EventProfiler : For the %1.1f %s event with the components of %s, we find %d events. Date Range = (%s) to (%s)." % (
event_strategy.f_size,
event_strategy.s_feature,
event_strategy.s_list_name,
i_event_counter,
dt_start,
dt_end,
)
print "TechInv : Profiling Events"
ep.profile_event(event_strategy, ls_symbols, dt_start, dt_end, df_events, 100, 5)
print ""
ms.simulate_market(event_strategy)
event_strategy.s_bench_sym = "$SPX"
print ""
pa.analyze_event(event_strategy, dt_start, dt_end)
def main_manual(sd= dt.datetime(2008, 1, 2), ed= dt.datetime(2009, 12, 31), out_file = "default.png", out_subtitle = "Default"):
'''
Main script to run an experiment with the manual strategy in comparison to buy and hold benchmark.
'''
# Set-up initial parameters for simulation
symbol = "JPM"
sv = 100000
commission = 9.95;
impact = 0.005;
# Calculate optimal portfolio values
manual_trades = testPolicy(symbol = symbol, sd = sd, ed = ed, sv = sv)
manual_port_vals = ms.compute_portvals(manual_trades, start_val = sv, commission = commission, impact = impact)
manual_port_vals = manual_port_vals / manual_port_vals.iloc[0,:]
manual_port_vals.rename(columns = {"Portfolio Value":"Manual"}, inplace = True)
# Calculate benchmark portfolio values
benchmark_trades = pd.DataFrame(data = [["JPM","BUY",1000]], index = [sd, ed], columns = ["Symbol", "Order", "Shares"])
benchmark_port_vals = ms.compute_portvals(benchmark_trades, start_val = sv, commission = commission, impact = impact)
benchmark_port_vals = benchmark_port_vals / benchmark_port_vals.iloc[0,:]
benchmark_port_vals.rename(columns = {"Portfolio Value":"Benchmark"}, inplace = True)
port_vals = pd.DataFrame(benchmark_port_vals["Benchmark"], index = benchmark_port_vals.index)
port_vals["Manual"] = manual_port_vals["Manual"]
port_vals.fillna(method = 'ffill', inplace=True)
# Plot optimal strategy
plt.gcf().subplots_adjust(bottom=0.2)
def experiment_2_helper(symbol,
start_train,
end_train,
start_test,
end_test,
sv=100000,
commission=0.0,
impact=0.0):
np.random.seed(1000)
random.seed(1000)
slearner = sl.StrategyLearner(impact=impact)
slearner.addEvidence(symbol=symbol, sd=start_train, ed=end_train, sv=sv)
# In-Sample Experiment 1
# Calculate manual strategy portfolio values
manual_trades = man.testPolicy(symbol=symbol,
sd=start_test,
ed=end_test,
sv=sv)
manual_port_vals = ms.compute_portvals(manual_trades,
start_val=sv,
commission=commission,
impact=impact)
manual_port_vals = manual_port_vals / manual_port_vals.iloc[0, :]
manual_port_vals.rename(columns={"Portfolio Value": "Manual"},
inplace=True)
# Calculate benchmark portfolio values
dates = pd.date_range(start_test, end_test)
syms = [symbol]
price_range = get_data(syms, dates) # automatically adds SPY
benchmark_trades = pd.DataFrame(
data=[[symbol, "BUY", 1000]],
index=[price_range.index[0], price_range.index[-1]],
columns=["Symbol", "Order", "Shares"])
bench_port_vals = ms.compute_portvals(benchmark_trades,
start_val=sv,
commission=commission,
impact=impact)
bench_port_vals = bench_port_vals / bench_port_vals.iloc[0, :]
bench_port_vals.rename(columns={"Portfolio Value": "Benchmark"},
inplace=True)
# Calculate strategy learner portfolio values
temp_strategylearner_trades = slearner.testPolicy(symbol=symbol,
sd=start_test,
ed=end_test,
sv=sv)
strategylearner_trades = pd.DataFrame(
columns=['Order', 'Symbol', 'Shares'])
for row_idx in temp_strategylearner_trades.index:
nshares = temp_strategylearner_trades.loc[row_idx][0]
if nshares == 0:
continue
order = 'SELL' if nshares < 0 else 'BUY'
new_row = pd.DataFrame([
[order, symbol, abs(nshares)],
],
columns=['Order', 'Symbol', 'Shares'],
index=[
row_idx,
])
strategylearner_trades = strategylearner_trades.append(new_row)
strategylearner_port_vals = ms.compute_portvals(strategylearner_trades,
start_val=sv,
commission=commission,
impact=impact)
strategylearner_port_vals = strategylearner_port_vals / strategylearner_port_vals.iloc[
0, :]
strategylearner_port_vals.rename(columns={"Portfolio Value": "Strategy"},
inplace=True)
port_vals = pd.DataFrame(bench_port_vals["Benchmark"],
index=bench_port_vals.index)
port_vals["Manual"] = manual_port_vals["Manual"]
port_vals["Strategy"] = strategylearner_port_vals["Strategy"]
port_vals.fillna(method='ffill', inplace=True)
mcr, madr, msddr, msr = id.calculate_portfolio_metrics(manual_port_vals)
bcr, badr, bsddr, bsr = id.calculate_portfolio_metrics(bench_port_vals)
scr, sadr, ssddr, ssr = id.calculate_portfolio_metrics(
strategylearner_port_vals)
return mcr, madr, msddr, msr, bcr, badr, bsddr, bsr, scr, sadr, ssddr, ssr
def run_experiment_1(symbol,
start_train,
end_train,
start_test,
end_test,
sv=100000,
commission=0.0,
impact=0.0,
output="default.png"):
np.random.seed(1000)
random.seed(1000)
slearner = sl.StrategyLearner(impact=impact)
slearner.addEvidence(symbol=symbol, sd=start_train, ed=end_train, sv=sv)
# In-Sample Experiment 1
# Calculate manual strategy portfolio values
manual_trades = man.testPolicy(symbol=symbol,
sd=start_test,
ed=end_test,
sv=sv)
manual_port_vals = ms.compute_portvals(manual_trades,
start_val=sv,
commission=commission,
impact=impact)
manual_port_vals = manual_port_vals / manual_port_vals.iloc[0, :]
manual_port_vals.rename(columns={"Portfolio Value": "Manual"},
inplace=True)
# Calculate benchmark portfolio values
dates = pd.date_range(start_test, end_test)
syms = [symbol]
price_range = get_data(syms, dates) # automatically adds SPY
benchmark_trades = pd.DataFrame(
data=[[symbol, "BUY", 1000]],
index=[price_range.index[0], price_range.index[-1]],
columns=["Symbol", "Order", "Shares"])
bench_port_vals = ms.compute_portvals(benchmark_trades,
start_val=sv,
commission=commission,
impact=impact)
bench_port_vals = bench_port_vals / bench_port_vals.iloc[0, :]
bench_port_vals.rename(columns={"Portfolio Value": "Benchmark"},
inplace=True)
# Calculate strategy learner portfolio values
temp_strategylearner_trades = slearner.testPolicy(symbol=symbol,
sd=start_test,
ed=end_test,
sv=sv)
strategylearner_trades = pd.DataFrame(
columns=['Order', 'Symbol', 'Shares'])
for row_idx in temp_strategylearner_trades.index:
nshares = temp_strategylearner_trades.loc[row_idx][0]
if nshares == 0:
continue
order = 'SELL' if nshares < 0 else 'BUY'
new_row = pd.DataFrame([
[order, symbol, abs(nshares)],
],
columns=['Order', 'Symbol', 'Shares'],
index=[
row_idx,
])
strategylearner_trades = strategylearner_trades.append(new_row)
strategylearner_port_vals = ms.compute_portvals(strategylearner_trades,
start_val=sv,
commission=commission,
impact=impact)
strategylearner_port_vals = strategylearner_port_vals / strategylearner_port_vals.iloc[
0, :]
strategylearner_port_vals.rename(columns={"Portfolio Value": "Strategy"},
inplace=True)
port_vals = pd.DataFrame(bench_port_vals["Benchmark"],
index=bench_port_vals.index)
port_vals["Manual"] = manual_port_vals["Manual"]
port_vals["Strategy"] = strategylearner_port_vals["Strategy"]
port_vals.fillna(method='ffill', inplace=True)
# Plot in-sample strategy
plt.figure()
plt.gcf().subplots_adjust(bottom=0.2)
plt.plot(port_vals["Benchmark"], color='g', linewidth=0.7)
plt.plot(port_vals["Manual"], color='r', linewidth=0.7)
plt.plot(port_vals["Strategy"], color='b', linewidth=0.7)
plt.legend(["Benchmark", "Manual", "StrategyLearner"])
plt.title(
"Portfolio Values: Benchmark vs. Manual Strategy vs. StrategyLearner\n",
fontsize=10)
plt.ylabel("Normalized Values", fontsize=8)
plt.xlabel("Date Range", fontsize=8)
plt.xticks(rotation=45)
plt.savefig(output)
mcr, madr, msddr, msr = id.calculate_portfolio_metrics(manual_port_vals)
bcr, badr, bsddr, bsr = id.calculate_portfolio_metrics(bench_port_vals)
scr, sadr, ssddr, ssr = id.calculate_portfolio_metrics(
strategylearner_port_vals)
print("--------------------Manual Strategy--------------------")
print("Cumulative Return:", mcr)
print("Average Daily Return:", madr)
print("Stdev Daily Return:", msddr)
print("Sharpe Ratio:", msr)
print("--------------------Benchmark Strategy-----------------")
print("Cumulative Return:", bcr)
print("Average Daily Return:", badr)
print("Stdev Daily Return:", bsddr)
print("Sharpe Ratio:", bsr)
print("--------------------StrategyLearner---------------------")
print("Cumulative Return:", scr)
print("Average Daily Return:", sadr)
print("Stdev Daily Return:", ssddr)
print("Sharpe Ratio:", ssr)
