def testCode(): manual_strategy = compute_portvals(testPolicy(),100000) benchmark_val = compute_portvals(benchmark(),100000) learner = sl.StrategyLearner() learner.addEvidence('JPM',dt.datetime(2008,1,1),dt.datetime(2009,12,31),100000) q_trades = learner.testPolicy('JPM',dt.datetime(2008,1,1),dt.datetime(2009,12,31),100000) learner_strategy = compute_portvals(q_trades,100000) first_benchmark = benchmark_val.iloc[0] first_manual_strategy = manual_strategy.iloc[0] first_learner_strategy = learner_strategy.iloc[0] # print benchmark_val # print manual_strategy # print learner_strategy print ' ' print ' ' print ' ' print 'Benchmark - In Sample' print_stats(benchmark_val) print '_______________________________________' print 'Manual Strategy - In Sample' print_stats(manual_strategy) print '_______________________________________' print 'Learner Strategy - In Sample' print_stats(learner_strategy) print '_______________________________________' price_calc = calculate_prices() print 'Cumulative Return of JPM, Out of Sample -> ', price_calc.iloc[-1]/price_calc.iloc[0] matplotlib.pyplot.plot(benchmark_val/first_benchmark, label='Benchmark', color='b') matplotlib.pyplot.plot(manual_strategy/first_manual_strategy, label='Manual Rule Based Trader', color='k') matplotlib.pyplot.plot(learner_strategy/first_learner_strategy, label='Strategy Learner Trader', color='g') matplotlib.pyplot.xlim([dt.datetime(2008,1,1),dt.datetime(2009,12,31)]) matplotlib.pyplot.xticks(rotation=10) matplotlib.pyplot.xlabel('Date') matplotlib.pyplot.ylabel('Normalized Portfolio Value') matplotlib.pyplot.title('Portfolio Comparison - In Sample') matplotlib.pyplot.legend() matplotlib.pyplot.savefig('experiment1.pdf')
def compare_strategies(verbose=False): symbol = "JPM" start_date = dt.datetime(2008, 1, 1) end_date = dt.datetime(2009, 12, 31) start_val = 100000 impact = 0.005 commission = 9.95 # Benchmark benchmark = get_benchmark(symbol, start_date, end_date, start_val) # Manual Strategy ms_trades = testPolicy(symbol, start_date, end_date, start_val) portvals_MS = compute_portvals(symbol, ms_trades, start_val, commission=commission, impact=impact) # Strategy Learner learner = sl.StrategyLearner(verbose=False, commission=commission, impact=impact) learner.add_evidence(symbol, start_date, end_date, start_val) sl_trades = learner.testPolicy(symbol, start_date, end_date, start_val) portvals_SL = compute_portvals(symbol, sl_trades, start_val, commission=commission, impact=impact) # Normalize benchmark = benchmark / benchmark.iloc[0] portvals_MS = portvals_MS / portvals_MS.iloc[0] portvals_SL = portvals_SL / portvals_SL.iloc[0] plt.figure(figsize=(8, 6)) plt.plot(benchmark, label='Benchmark', color='orange') plt.plot(portvals_MS, label='Manual Strategy', color='black') plt.plot(portvals_SL, label='Strategy Learner (RT + BagLearner)', color='green') plt.title('JPM') plt.xlabel('Date') plt.ylabel('Nomralized Price') plt.legend() plt.savefig('experiment1.png') ms_cr, ms_adr, ms_std, ms_sr = assess_portfolio(portvals_MS) sl_cr, sl_adr, sl_std, sl_sr = assess_portfolio(portvals_SL) bench_cr, bench_adr, bench_std, bench_sr = assess_portfolio(benchmark) if verbose: print(' Results saved in experiment1.png ') # Compare portfolio against Benchmark print(f"Date Range: {start_date} to {end_date}") print() print(f"Sharpe Ratio of Fund - Manual Strategy: {ms_sr}") print(f"Sharpe Ratio of Fund - Strategy learner: {sl_sr}") print(f"Sharpe Ratio of Fund - Benchmark : {bench_sr}") print() print(f"Cumulative Return of Fund - Manual Strategy: {ms_cr}") print(f"Cumulative Return of Fund - Strategy learner: {sl_cr}") print(f"Cumulative Return of Fund - Benchmark : {bench_cr}") print() print(f"Standard Deviation of Fund - Manual Strategy: {ms_std}") print(f"Standard Deviation of Fund - Strategy learner: {sl_std}") print(f"Standard Deviation of Fund - Benchmark : {bench_std}") print() print(f"Average Daily Return of Fund - Manual Strategy: {ms_adr}") print(f"Average Daily Return of Fund - Strategy learner: {sl_adr}") print(f"Average Daily Return of Fund - Benchmark : {bench_adr}") print() print(f"Start Value: {start_val}") print( f"Final Portfolio Value - Manual Strategy: {portvals_MS.iloc[-1] * start_val}" ) print( f"Final Portfolio Value - Strategy learner: {portvals_SL.iloc[-1] * start_val}" ) print( f"Final Portfolio Value - Benchmark: {benchmark.iloc[-1] * start_val}" )
def main(symbol="JPM", start_date=dt.datetime(2008, 1, 1), end_date=dt.datetime(2009, 12, 31)): np.random.seed(3**9) random.seed(3**9) print "Random seed is: ", 3**9, "\n\n" # Manual Strategy (df_trades, indicators_manual) = testPolicy(symbol=symbol, sd=start_date, ed=end_date, sv=100000) #df_trades.to_csv("manual.csv") Manual_trade_dates = df_trades[symbol].nonzero() #print SL_trade_dates[0][0] print "\nFirst trading date of Manual Strategy: ", df_trades.index.values[ Manual_trade_dates[0][0]] print "Trading times of Manual Strategy: ", len( Manual_trade_dates[0]), "\n" Manual_portval = compute_portvals(df_trades, start_val=100000, commission=0.0, impact=0.0, symbol=symbol) Manual_portval_stats = compute_portvals_stats(Manual_portval) # Learning Strategy strategy_learner = sl.StrategyLearner(verbose=False, impact=0.0) strategy_learner.addEvidence(symbol=symbol, sd=start_date, ed=end_date, sv=100000) df_SL = strategy_learner.testPolicy(symbol=symbol, sd=start_date, ed=end_date, sv=100000) SL_trade_dates = df_SL[symbol].nonzero() #print SL_trade_dates[0][0] print "\nFirst trading date of Strategy Learner: ", df_SL.index.values[ SL_trade_dates[0][0]] print "Trading times of Strategy Learner: ", len(SL_trade_dates[0]), "\n" SL_portval = compute_portvals(df_SL, start_val=100000, commission=0.0, impact=0.0, symbol=symbol) SL_portval_stats = compute_portvals_stats(SL_portval) # Benchmark df_benchmark = Benchmark(symbol=symbol, sd=start_date, ed=end_date, sv=100000) BM_trade_dates = df_benchmark[symbol].nonzero() #print df_benchmark print "\nFirst trading date of Benchmark: ", df_benchmark.index.values[ BM_trade_dates[0][0]] print "Trading times of Benchmark: ", len(BM_trade_dates[0]), "\n" Benchmark_portval = compute_portvals(df_benchmark, start_val=100000, commission=0.0, impact=0.0, symbol=symbol) Benchmark_portval_stats = compute_portvals_stats(Benchmark_portval) ############################ # # Print Stats # ############################ print "Date Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Manual: {}".format(Manual_portval_stats[0]) print "Sharpe Ratio of SL: {}".format(SL_portval_stats[0]) print "Sharpe Ratio of Benchmark: {}".format(Benchmark_portval_stats[0]) print print "Cumulative Return of Manual: {}".format(Manual_portval_stats[1]) print "Cumulative Return of SL: {}".format(SL_portval_stats[1]) print "Cumulative Return of Benchmark: {}".format( Benchmark_portval_stats[1]) print print "Average Daily Return of Manual: {}".format(Manual_portval_stats[2]) print "Average Daily Return of SL: {}".format(SL_portval_stats[2]) print "Average Daily Return of Benchmark: {}".format( Benchmark_portval_stats[2]) print print "Standard Deviation of Manual: {}".format(Manual_portval_stats[3]) print "Standard Deviation of SL: {}".format(SL_portval_stats[3]) print "Standard Deviation of Benchmark: {}".format( Benchmark_portval_stats[3]) print print "Final Portfolio Value Manual: {}".format(Manual_portval[-1]) print "Final Portfolio Value SL: {}".format(SL_portval[-1]) print "Final Portfolio Value Benchmark: {}".format(Benchmark_portval[-1]) portfolio_df = pd.DataFrame( index=Benchmark_portval.index, columns=['Manual Strategy', 'Strategy Learner', 'Benchmark']) portfolio_df['Manual Strategy'] = Manual_portval / Manual_portval[0] portfolio_df['Strategy Learner'] = SL_portval / SL_portval[0] portfolio_df['Benchmark'] = Benchmark_portval / Benchmark_portval[0] #manual_buy = indicators_manual[indicators_manual['Final_Signal'] == 1] #print manual_buy.index #manual_sell = indicators_manual[indicators_manual['Final_Signal'] == -1] #print manual_sell.index ax = portfolio_df.plot(fontsize=16, color=["blue", "red", "black"]) ax.set_xlabel("Dates", fontsize=16) ax.set_ylabel("Normalized Portfolio Values", fontsize=16) #ymin, ymax = ax.get_ylim() #plt.vlines(manual_buy.index,ymin,ymax,color='g') #plt.vlines(manual_sell.index,ymin,ymax,color='r') #filename = "Figure2.png" #plt.savefig(filename) figure = plt.gcf() # get current figure figure.set_size_inches(8, 6) figure.suptitle("Manual Strategy Vs. Strategy Learner Vs. Benchmark", fontsize=16) # when saving, specify the DPI figure.savefig("Figure1.png")
def plot_graphs(sd=dt.datetime(2008,1,1),ed=dt.datetime(2009,12,31),title="Strategy Learner vs Manual Strategy vs Benchmark (insample data)",symbol = 'JPM'): order_df = testPolicy(sd=sd,ed=ed,symbol=symbol) portvals = compute_portvals(order_df,symbol=symbol) cum_ret=(portvals[-1]/portvals[0])-1 daily_ret=(portvals/portvals.shift(1))-1 avg_daily_ret=daily_ret.mean() std_daily_ret=daily_ret.std() sharpe_ratio=np.sqrt(252)*(daily_ret).mean()/std_daily_ret # Portfolio details print(f"Cumulative Return of Manual Strategy: {cum_ret}") print() print(f"Standard Deviation of Manual Strategy: {std_daily_ret}") print() print(f"Average Daily Return of Strategy: {avg_daily_ret}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print() bench_order = order_df.copy().head(1) bench_order = bench_order.append(order_df.copy().tail(1)) bench_order.iloc[0] = 1000 bench_order.iloc[1:] = 0 bench_portvals = compute_portvals(bench_order,symbol=symbol) #print(bench_portvals) cum_ret=(bench_portvals[-1]/bench_portvals[0])-1 daily_ret=(bench_portvals/bench_portvals.shift(1))-1 avg_daily_ret=daily_ret.mean() std_daily_ret=daily_ret.std() sharpe_ratio=np.sqrt(252)*(daily_ret).mean()/std_daily_ret # Portfolio details print("-------------------------------------------------") print() print(f"Cumulative Return of Benchmark: {cum_ret}") print() print(f"Standard Deviation of Benchmark: {std_daily_ret}") print() print(f"Average Daily Return of Benchmark: {avg_daily_ret}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print() st = StrategyLearner() st.addEvidence(symbol=symbol,sd=sd,ed=ed,sv=100000) trades = st.testPolicy(symbol=symbol,sd=dt.datetime(2008,1,1),ed=dt.datetime(2009,12,31),sv=100000) strategy_portvals = compute_portvals(trades,symbol=symbol) cum_ret=(strategy_portvals[-1]/strategy_portvals[0])-1 daily_ret=(strategy_portvals/strategy_portvals.shift(1))-1 avg_daily_ret=daily_ret.mean() std_daily_ret=daily_ret.std() sharpe_ratio=np.sqrt(252)*(daily_ret).mean()/std_daily_ret # Portfolio details print("-------------------------------------------------") print() print(f"Cumulative Return of Strategy Learner: {cum_ret}") print() print(f"Standard Deviation of Strategy Learner: {std_daily_ret}") print() print(f"Average Daily Return of Strategy Learner: {avg_daily_ret}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print() portvals_nrm = portvals/portvals[0] bench_portvals_nrm = bench_portvals/bench_portvals[0] strategy_portvals_nrm = strategy_portvals/strategy_portvals[0] plt.figure(figsize=[12,8]) strategy_portvals_nrm.plot(label="Strategy Learner Portfolio",color="blue") portvals_nrm.plot(label="Manual Strategy Portfolio",color="red") bench_portvals_nrm.plot(label="Benchmark Portfolio",color="green") plt.legend(loc="upper left") plt.xlabel("Date") plt.ylabel("Normalized Portfolio value") plt.xlim([sd,ed]) #plt.ylim([0.65,1.5]) plt.title(title) plt.savefig("experiment1.png")
# trades.values[40,:] = -1000 # add a SELL # trades.values[41,:] = 1000 # add a BUY # trades.values[60,:] = -2000 # go short from long # trades.values[61,:] = 2000 # go long from short # trades.values[-1,:] = -1000 #exit on the last day # if self.verbose: print type(trades) # it better be a DataFrame! # if self.verbose: print trades # if self.verbose: print prices_all # return trades if __name__=="__main__": learner = StrategyLearner(impact=0.005) learner.addEvidence('JPM',dt.datetime(2008,1,1),dt.datetime(2009,12,31),100000) q_trades = learner.testPolicy('JPM',dt.datetime(2008,1,1),dt.datetime(2009,12,31),100000) manual_trades = testPolicy() print '_________ Benchmark _________' print compute_portvals(benchmark(),100000,9.95,0.005) print '_________ Man Strat _________' print compute_portvals(manual_trades,100000,9.95,0.005) print '_________ Q Learner _________' print compute_portvals(q_trades,100000,9.95,0.005) ## to do, properly discretize values of bb_val, create state and pass to learner
test = learner.testPolicy(symbol, sd=sd, ed=ed, sv=100000) # st_trades = trades_ST(test, 'JPM') # st_port_val = compute_portvals(st_trades, sd, ed, 100000, 0, 0) # print test # print test st_port_val = compute_portvals(test, start_val=100000, commission=0, impact=0) # print "strategy port val", st_port_val #benchmark bench = st.benchMark(symbol, sd, ed, 100000) bm_port_val = compute_portvals(bench, 100000, 0, 0) # print "bench port val", bench_port_val # ManualStrategy trades = testPolicy(symbol, sd=sd, ed=ed, sv=100000) ms_port_val = compute_portvals(trades, 100000, 0, 0) # print ms_port_val ms_port_val = ms_port_val / ms_port_val[0] ms_cumu_ret = (ms_port_val[-1] / ms_port_val[0]) - 1 daily_rets = ms_port_val.copy() daily_rets[1:] = (ms_port_val[1:] / ms_port_val[:-1].values) - 1 daily_rets.ix[0] = 0 ms_avg_daily_ret = daily_rets.mean() ms_std_daily_ret = daily_rets.std() ms_sr = (np.sqrt(252.0) * ms_avg_daily_ret) / ms_std_daily_ret
#trades = learner.testPolicy(symbol="JPM",sd=dt.datetime(2008,1,1),ed=dt.datetime(2009,12,31),sv=100000) #st_port_val = evalPolicy2("JPM",trades,100000,dt.datetime(2008,1,1),dt.datetime(2009,12,31),0,0) # Benchmark bench = pd.DataFrame(columns=['Date', 'Symbol', 'Order', 'Shares']) bench.loc[0] = [ prices_all.index[0].strftime('%Y-%m-%d'), 'JPM', 'BUY', 1000 ] bench.loc[1] = [ prices_all.index[-1].strftime('%Y-%m-%d'), 'JPM', 'SELL', 1000 ] bench_port_val = compute_portvals(bench, sd, ed, 100000, 0, 0) # ManualStrategy trades, buydate, selldate = testPolicy(symbol=['JPM'], sd=sd, ed=ed, sv=100000) ms_port_val = compute_portvals(trades, sd, ed, 100000, 0, 0) # Printing Portfolio statistics daily_returns = (ms_port_val / ms_port_val.shift(1)) - 1 daily_returns = daily_returns[1:] cr = (ms_port_val.iloc[-1] / ms_port_val.iloc[0]) - 1 adr = daily_returns.mean() sddr = daily_returns.std() a = np.sqrt(252.0) sr = (a * (adr)) / sddr ''' print "Manual Strategy Stats" print "CR " + str(cr) print "Avg of daily returns " + str(adr)