def theoretically_optimal_strategy(sd=dt(2008, 1, 1), ed=dt(2009, 12, 31), symbols=['JPM'], commission=0.00, impact=0.00): df_trades = testPolicy(symbols=symbols, sd=sd, ed=ed) portvals = ms.compute_portvals(df_trades, sd=sd, ed=ed, commission=commission, impact=impact) portvals_benchmark = ms.portfolio_vals_benchmark(sd=sd, ed=ed, symbols=symbols) final_portvals_benchmark = ms.compute_portvals(portvals_benchmark, sd=sd, ed=ed, commission=commission, impact=impact) ms.compute_portfolio_stats(portvals) ms.compute_portfolio_stats(final_portvals_benchmark) adjusted_portvals = portvals / portvals.ix[0, :] adjusted_portvals_benchmark = final_portvals_benchmark / final_portvals_benchmark.ix[ 0, :] plot_theoretically_optimal_strategy(symbols, adjusted_portvals, adjusted_portvals_benchmark)
def manual_strategy(sd=dt(2008, 1, 1), ed=dt(2009, 12, 31), symbols=['JPM'], master='in_sample'): df_trades = testPolicy(symbols=symbols, master=master, sd=sd, ed=ed) portvals = ms.compute_portvals(df_trades, sd=sd, ed=ed) portvals_benchmark = ms.portfolio_vals_benchmark(sd=sd, ed=ed, symbols=symbols) final_portvals_benchmark = ms.compute_portvals(portvals_benchmark, sd=sd, ed=ed) ms.compute_portfolio_stats(portvals) ms.compute_portfolio_stats(final_portvals_benchmark) adjusted_portvals = portvals / portvals.ix[0, :] adjusted_portvals_benchmark = final_portvals_benchmark / final_portvals_benchmark.ix[ 0, :] plot_in_out_sample_comparative_benchmark(symbols, adjusted_portvals, adjusted_portvals_benchmark, df_trades, master=master)
def main(): start_date = '2008-1-1' end_date = '2009-12-31' symbols = 'JPM' bps = BestPossibleStrategy() df_trades = bps.testPolicy(symbols, start_date, end_date, 100000) port_vals = compute_portvals(orders=df_trades, start_val=100000, commission=0.00, impact=0.00) df_bchm = bps.benchMark(symbols, start_date, end_date, 100000) port_vals_bchm = compute_portvals(orders=df_bchm, start_val=100000, commission=0.00, impact=0.00) #print port_vals, port_vals_bchm cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats( port_vals) cum_ret_bchm, avg_daily_ret_bchm, std_daily_ret_bchm, sharpe_ratio_bchm = compute_portfolio_stats( port_vals_bchm) # Compare portfolio against $SPX print "Date Range: {} to {}".format(start_date, end_date) print print "Cumulative Return of Portfolio: {}".format(cum_ret) print "Cumulative Return of Benchmark: {}".format(cum_ret_bchm) print print "Standard Deviation of Portfolio: {}".format(std_daily_ret) print "Standard Deviation of Benchmark: {}".format(std_daily_ret_bchm) print print "Average Daily Return of Portfolio: {}".format(avg_daily_ret) print "Average Daily Return of Benchmark: {}".format(avg_daily_ret_bchm) print print "Sharpe Ratio of Portfolio: {}".format(sharpe_ratio) print "Sharpe Ratio of Benchmark: {}".format(sharpe_ratio_bchm) print print "Final Portfolio Value: {}".format(port_vals[-1]) print "Final Benchmark Value: {}".format(port_vals_bchm[-1]) port_vals_bchm_norm = port_vals_bchm / port_vals_bchm.ix[0, ] port_vals_norm = port_vals / port_vals.ix[0, ] port_vals_bchm_norm = port_vals_bchm_norm.to_frame() port_vals_norm = port_vals_norm.to_frame() f1 = plt.figure(1) re = port_vals_bchm_norm.join(port_vals_norm, lsuffix='_benchmark', rsuffix='_portfolio') re.columns = ['Benchmark', 'Value of the best possible portfolio'] ax = re.plot( title="Normalized Benchmark and Value of The Best Possible Portfolio", fontsize=12, color=["blue", "black"]) ax.set_xlabel("Date") ax.set_ylabel("Portfolio") f1.show() plt.show()
def plotStuff(): slr = sl.StrategyLearner(verbose=False, impact=0.05) slr.addEvidence(symbol="JPM", ) df_trades_sl = slr.testPolicy(symbol="JPM", sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 1, 1), sv=100000) df_trades_sl['Symbol'] = 'JPM' df_trades_sl['Order'] = 'BUY' df_trades_sl.loc[df_trades_sl.Shares < 0, 'Order'] = 'SELL' df_trades_sl = df_trades_sl[df_trades_sl.Shares != 0] df_trades_sl = df_trades_sl[['Symbol', 'Order', 'Shares']] portvals_sl = ms.compute_portvals(df_trades_sl, start_val=100000, impact=0.05) df_trades = mst.testPolicy(symbol="JPM", sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 1, 1), sv=100000) portvals = ms.compute_portvals(df_trades, start_val=100000, impact=0.05) syms = ['SPY'] dates = pd.date_range(dt.datetime(2008, 1, 1), dt.datetime(2009, 1, 1)) prices_all = ut.get_data(syms, dates) # automatically adds SPY prices_SPY = prices_all['SPY'] # only SPY, for comparison later prices_SPY_normalized = normalize_stocks(prices_SPY) prices_portval_normalized = normalize_stocks(portvals) prices_sl_normalized = normalize_stocks(portvals_sl) chart_df = pd.concat([ prices_portval_normalized, prices_SPY_normalized, prices_sl_normalized ], axis=1) chart_df.columns = ['Manual Strategy', 'Benchmark', 'Strategy Learner'] chart_df.plot(grid=True, title='Comparing Manual strategy with Strategy Learner', use_index=True, color=['Black', 'Blue', 'Red']) cum_ret_sl, avg_daily_ret_sl, std_daily_ret_sl, sharpe_ratio_sl = ms.compute_portfolio_stats( prices_sl_normalized) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats( prices_portval_normalized) cum_ret_SPY, avg_daily_ret_SPY, std_daily_ret_SPY, sharpe_ratio_SPY = ms.compute_portfolio_stats( prices_SPY_normalized) print('Sharpe Ratio Strategy Learner:{}'.format(sharpe_ratio_sl)) print('Sharpe Ratio Manual Strategy:{}'.format(sharpe_ratio)) print('Sharpe Ratio Benchmark:{}'.format(sharpe_ratio_SPY)) print('Cum Return Strategy Learner:{}'.format(cum_ret_sl)) print('Cum Return Manual Strategy:{}'.format(cum_ret)) print('Cum Return Benchmark:{}'.format(cum_ret_SPY)) plt.show()
def test_code(): df_trades = testPolicy() portvals = ms.compute_portvals(df_trades, start_val=100000, commission=0, impact=0) if isinstance(portvals, pd.DataFrame): portvals = portvals[ portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" # Calculate stats of Portfolio cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats(portvals) # Benchmark Portfolio df_benchmark = pd.DataFrame(index=df_trades.index, columns=["JPM"]) df_benchmark.loc[df_trades.index] = 0 df_benchmark.loc[df_trades.index[0]] = 1000 # Buying 1000 shares of JPM portvals_benchmark = ms.compute_portvals(df_benchmark, start_val=100000, commission=0, impact=0) # Calculate stats of Benchmark Portfolio cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = \ ms.compute_portfolio_stats(portvals_benchmark[portvals_benchmark.columns[0]]) # Normalize Portfolio and Benchmark Portfolio portvals_norm = portvals / portvals.iloc[0] portvals_benchmark = portvals_benchmark / portvals_benchmark.iloc[0] # Generate Plot figure, axis = plt.subplots() portvals_norm.plot(ax=axis, color='r') portvals_benchmark.plot(ax=axis, color='g') plt.title("Comparison of Theoretically Optimal Portfolio vs Benchmark") plt.legend(["Theoretically Optimal Strategy", "Benchmark"]) plt.xlabel("Date") plt.ylabel("Normalized Portfolio Value") plt.savefig("OptimalStrategy.png") # plt.show() # Display Portfolio Stats start_date = portvals.index[0] end_date = portvals.index[-1] print(f"Date Range: {start_date} to {end_date}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark: {sharpe_ratio_bench}") print() print(f"Cumulative Return of Fund: {cum_ret}") print(f"Cumulative Return of Benchmark: {cum_ret_bench}") print() print(f"Standard Deviation of Fund: {std_daily_ret}") print(f"Standard Deviation of Benchmark: {std_daily_ret_bench}") print() print(f"Average Daily Return of Fund: {avg_daily_ret}") print(f"Average Daily Return of Benchmark: {avg_daily_ret_bench}") print() print(f"Final Portfolio Value: {portvals[-1]}")
def ManualStrategyMain(verbose=False, impact=0.0, commission=0.0): start_date = '2008-1-1' end_date = '2009-12-31' start_money = 100000 symbols = 'JPM' ms = ManualStrategy(verbose, impact, commission) # 1. Run the testPolicy for symbol XXX df_trades = ms.testPolicy(symbols, start_date, end_date, start_money) port_vals = mk.compute_portvals(df_trades, start_money, commission, impact) print('port_vals') print(port_vals) # 2. Run the benchmark df_bchm = ms.benchMark(symbols, start_date, end_date, start_money) port_vals_bench = mk.compute_portvals(df_bchm, start_money, commission, impact) print() print() print('================') print('port_vals_bench') print(port_vals_bench) # 3. calculate: Cumulative return of the benchmark and portfolio # Stdev of daily returns of benchmark and portfolio # Mean of daily returns of benchmark and portfolio cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = mk.compute_portfolio_stats( port_vals) cum_ret_b, avg_daily_ret_b, std_daily_ret_b, sharpe_ratio_b = mk.compute_portfolio_stats( port_vals_bench) # 4. Compare portfolio against Benchmark print() print() print('================') print(f"Date Range: {start_date} to {end_date}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark : {sharpe_ratio_b}") print() print(f"Cumulative Return of Fund: {cum_ret}") print(f"Cumulative Return of Benchmark : {cum_ret_b}") print() print(f"Standard Deviation of Fund: {std_daily_ret}") print(f"Standard Deviation of Benchmark : {std_daily_ret_b}") print() print(f"Average Daily Return of Fund: {avg_daily_ret}") print(f"Average Daily Return of Benchmark : {avg_daily_ret_b}")
def testCode(sym, sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,12,31),\ sv = 100000, chart =False, name='InSample_ManualStrategy'): prices = get_data(sym, pd.date_range(sd,ed)) prices.fillna(method='ffill', inplace=True) prices.fillna(method='bfill', inplace=True) prices = prices[sym] #orders = testPolicy(symbol=sym, sd=sd, ed=ed, sv=sv) impacts = [0,1.5, 2, 5] #df = [] strat_orders_0 = Strategy_Learner_code(sym=sym[0],sd=sd,ed=ed, c0=sv, impact = impacts[0])[0] strat_orders_005 = Strategy_Learner_code(sym=sym[0],sd=sd,ed=ed, c0=sv, impact = impacts[1])[0] strat_orders_01 = Strategy_Learner_code(sym=sym[0],sd=sd,ed=ed, c0=sv, impact = impacts[2])[0] strat_orders_02 = Strategy_Learner_code(sym=sym[0],sd=sd,ed=ed, c0=sv, impact = impacts[3])[0] #strat_orders.columns = [im] #print type(strat_orders_0) print len(strat_orders_0.index) print len(strat_orders_005.index) print len(strat_orders_01.index) print len(strat_orders_02.index) #df.append(strat_orders) #df = pd.concat(df, axis=1) #print df #manual portvals #portvals = ms.compute_portvals(df_trades = orders, start_val = sv) #if isinstance(portvals, pd.DataFrame): # portvals = portvals[portvals.columns[0]] # just get the first column #else: # "warning, code did not return a DataFrame" #strategy portvals strat_portvals_0 = ms.compute_portvals(df_trades = strat_orders_0, start_val = sv, impact=impacts[0]) strat_portvals_01 = ms.compute_portvals(df_trades = strat_orders_01, start_val = sv, impact=impacts[1]) strat_portvals_02 = ms.compute_portvals(df_trades = strat_orders_02, start_val = sv, impact=impacts[2]) strat_portvals_005 = ms.compute_portvals(df_trades = strat_orders_005, start_val = sv, impact=impacts[3]) if isinstance(strat_portvals_0, pd.DataFrame): strat_portvals_0 = strat_portvals_0[strat_portvals_0.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" if isinstance(strat_portvals_01, pd.DataFrame): strat_portvals_01 = strat_portvals_01[strat_portvals_01.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" if isinstance(strat_portvals_02, pd.DataFrame): strat_portvals_02 = strat_portvals_02[strat_portvals_02.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" if isinstance(strat_portvals_005, pd.DataFrame): strat_portvals_005 = strat_portvals_005[strat_portvals_005.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" # Benchmark #orders_bench = orders.copy() #orders_bench.ix[1:-1,:] = 0 #orders_bench.ix[0] = 1000 #orders_bench.ix[-1] = 0 #orders_bench = orders_bench[(orders_bench!=0).any(axis=1)] #portvals_bench = ms.compute_portvals(df_trades = orders_bench, start_val = sv) #if isinstance(portvals_bench, pd.DataFrame): # portvals_bench = portvals_bench[portvals_bench.columns[0]] # just get the first column #else: # "warning, code did not return a DataFrame" if chart: prices = ind.normalize(prices) #portvals = ind.normalize(portvals) #portvals_bench = ind.normalize(portvals_bench) strat_portvals_0 = ind.normalize(strat_portvals_0) strat_portvals_01 = ind.normalize(strat_portvals_01) strat_portvals_02 = ind.normalize(strat_portvals_02) strat_portvals_005 = ind.normalize(strat_portvals_005) df_temp = pd.concat([strat_portvals_0,strat_portvals_01,strat_portvals_02,strat_portvals_005],\ columns=['0', '0.01', '0.02', '0.005'], axis=1) title = name + "Strategy vs. impactk" f = df_temp.plot(title = title, linewidth=1.0,\ color='black') f.set_xlabel("Date") f.set_ylabel("Value") plt.grid(True) #portvals_bench.plot(ax=f, linewidth=1.0, legend=True,label='Benchmark', color='blue') #strat_portvals.plot(ax=f, linewidth=1.0, legend=True, label='Strat', color = 'red') f.legend(loc='upper left', prop={'size':5}) #f2 = f.twinx() #prices.plot(ax=f2, linewidth=0.7, label = 'Prices', color='r') #f2.set_ylabel('Prices') #f2.legend(loc='upper right', prop={'size':5}) #for index, row in orders.iterrows(): # if row.values[0] == 1000: # plt.axvline(x=index, color='g', linestyle='--', lw=0.7, linewidth=0.3) # if row.values[0] == -1000: # plt.axvline(x=index, color='r', linestyle='--', lw=0.7, linewidth=0.3) plt.savefig(name) # Get portfolio stats start_date = strat_portvals_0.index.min() end_date = strat_portvals_0.index.max() #cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench \ # = ms.compute_portfolio_stats(portvals_bench) #cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio \ # = ms.compute_portfolio_stats(portvals) #s_cum_ret, s_avg_daily_ret, s_std_daily_ret, s_sharpe_ratio \ # = ms.compute_portfolio_stats(strat_portvals) s_cum_ret_0 = ms.compute_portfolio_stats(strat_portvals_0) s_cum_ret_01 = ms.compute_portfolio_stats(strat_portvals_01) s_cum_ret_02 = ms.compute_portfolio_stats(strat_portvals_02) s_cum_ret_005 = ms.compute_portfolio_stats(strat_portvals_005) # Compare portfolio against $SPX print "Date Range: {} to {}".format(start_date, end_date) print print "Cumulative Return of Strat0: {}".format(s_cum_ret_0) print "Cumulative Return of Strat01: {}".format(s_cum_ret_01) print "Cumulative Return of Strat02: {}".format(s_cum_ret_02) print "Cumulative Return of Strat005: {}".format(s_cum_ret_005) print print "Final Portfolio Value of Strat 0: {}".format(strat_portvals_0[-1]) print "Final Portfolio Value of Strat 01: {}".format(strat_portvals_01[-1]) print "Final Portfolio Value of Strat 02: {}".format(strat_portvals_02[-1]) print "Final Portfolio Value of Strat 005: {}".format(strat_portvals_005[-1])
def main(): #display function for in sample data start_date = '2008-1-1' end_date = '2009-12-31' symbols = 'JPM' ms = ManualStrategy() df_trades = ms.testPolicy(symbols, start_date, end_date, 100000) port_vals = compute_portvals(orders = df_trades, start_val = 100000, commission=9.95, impact=0.005) df_bchm = ms.benchMark(symbols, start_date, end_date, 100000) port_vals_bchm = compute_portvals(orders = df_bchm, start_val = 100000, commission=9.95, impact=0.005) #print port_vals, port_vals_bchm cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats(port_vals) cum_ret_bchm, avg_daily_ret_bchm, std_daily_ret_bchm, sharpe_ratio_bchm = compute_portfolio_stats(port_vals_bchm) # Compare portfolio against $SPX print "Date Range(In Sample): {} to {}".format(start_date, end_date) print print "In Sample Cumulative Return of Portfolio: {}".format(cum_ret) print "In Sample Cumulative Return of Benchmark: {}".format(cum_ret_bchm) print print "In Sample Standard Deviation of Portfolio: {}".format(std_daily_ret) print "In Sample Deviation of Benchmark: {}".format(std_daily_ret_bchm) print print "In Sample Average Daily Return of Portfolio: {}".format(avg_daily_ret) print "In Sample Average Daily Return of Benchmark: {}".format(avg_daily_ret_bchm) print print "In Sample Sharpe Ratio of Portfolio: {}".format(sharpe_ratio) print "In Sample Sharpe Ratio of Benchmark: {}".format(sharpe_ratio_bchm) print print "In Sample Final Portfolio Value: {}".format(port_vals[-1]) print "In Sample Final Benchmark Value: {}".format(port_vals_bchm[-1]) port_vals_bchm_norm = port_vals_bchm / port_vals_bchm.ix[0,] port_vals_norm = port_vals / port_vals.ix[0,] port_vals_bchm_norm = port_vals_bchm_norm.to_frame() port_vals_norm = port_vals_norm.to_frame() long_entry = ms.long_entry short_entry = ms.short_entry f1 = plt.figure(1) re = port_vals_bchm_norm.join(port_vals_norm, lsuffix = '_benchmark', rsuffix = '_portfolio') re.columns = ['Benchmark','Value of the best possible portfolio'] ax = re.plot(title="Normalized Benchmark and Value of The Best Possible Portfolio", fontsize=12, color = ["blue","black"]) ax.set_xlabel("Date") ax.set_ylabel("Portfolio") ymin,ymax = ax.get_ylim() plt.vlines(long_entry,ymin,ymax,color='g') plt.vlines(short_entry,ymin,ymax,color='r') f2 = plt.figure(2) re = port_vals_bchm_norm.join(port_vals_norm, lsuffix = '_benchmark', rsuffix = '_portfolio') re.columns = ['Benchmark','Value of the best possible portfolio'] ax = re.plot(title="Normalized Benchmark and Value of The Best Possible Portfolio(In Sample)", fontsize=12, color = ["blue","black"]) ax.set_xlabel("Date") ax.set_ylabel("Portfolio") #f1.show() #display function for out of sample data start_date = '2010-1-1' end_date = '2011-12-31' symbols = 'JPM' ms = ManualStrategy() df_trades = ms.testPolicy(symbols, start_date, end_date, 100000) port_vals = compute_portvals(orders = df_trades, start_val = 100000, commission=9.95, impact=0.005) df_bchm = ms.benchMark(symbols, start_date, end_date, 100000) port_vals_bchm = compute_portvals(orders = df_bchm, start_val = 100000, commission=9.95, impact=0.005) #print port_vals, port_vals_bchm cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats(port_vals) cum_ret_bchm, avg_daily_ret_bchm, std_daily_ret_bchm, sharpe_ratio_bchm = compute_portfolio_stats(port_vals_bchm) # Compare portfolio against $SPX print "Date Range(Out of Sample): {} to {}".format(start_date, end_date) print print "Out of Sample Cumulative Return of Portfolio: {}".format(cum_ret) print "Out of Sample Cumulative Return of Benchmark: {}".format(cum_ret_bchm) print print "Out of Sample Standard Deviation of Portfolio: {}".format(std_daily_ret) print "Out of Sample Deviation of Benchmark: {}".format(std_daily_ret_bchm) print print "Out of Sample Average Daily Return of Portfolio: {}".format(avg_daily_ret) print "Out of Sample Average Daily Return of Benchmark: {}".format(avg_daily_ret_bchm) print print "Out of Sample Sharpe Ratio of Portfolio: {}".format(sharpe_ratio) print "Out of Sample Sharpe Ratio of Benchmark: {}".format(sharpe_ratio_bchm) print print "Out of Sample Final Portfolio Value: {}".format(port_vals[-1]) print "Out of Sample Final Benchmark Value: {}".format(port_vals_bchm[-1]) port_vals_bchm_norm = port_vals_bchm / port_vals_bchm.ix[0,] port_vals_norm = port_vals / port_vals.ix[0,] port_vals_bchm_norm = port_vals_bchm_norm.to_frame() port_vals_norm = port_vals_norm.to_frame() f3 = plt.figure(3) re = port_vals_bchm_norm.join(port_vals_norm, lsuffix = '_benchmark', rsuffix = '_portfolio') re.columns = ['Benchmark','Value of the best possible portfolio'] ax = re.plot(title="Normalized Benchmark and Value of The Best Possible Portfolio(Out of Sample)", fontsize=12, color = ["blue","black"]) ax.set_xlabel("Date") ax.set_ylabel("Portfolio") #f2.show() plt.show()
def testCode(sym, sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,12,31),\ sv = 100000, chart =False, name='InSample_ManualStrategy'): prices = get_data(sym, pd.date_range(sd, ed)) prices.fillna(method='ffill', inplace=True) prices.fillna(method='bfill', inplace=True) prices = prices[sym] orders = testPolicy(symbol=sym, sd=sd, ed=ed, sv=sv) strat_orders, bench_mark = Strategy_Learner_code(sym=sym[0], sd=sd, ed=ed, c0=sv) #orders.ix[0] = 1000 #orders.ix[-1] = -1000 #orders = orders.loc[(orders!=0).any(axis=1)] #orders.ix[0] = 0 #orders.ix[-1] = orders.ix[-2]*-1 #manual portvals portvals = ms.compute_portvals(df_trades=orders, start_val=sv) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" #strategy portvals strat_portvals = ms.compute_portvals(df_trades=strat_orders, start_val=sv) if isinstance(strat_portvals, pd.DataFrame): strat_portvals = strat_portvals[ strat_portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" # Benchmark orders_bench = orders.copy() orders_bench.ix[1:-1, :] = 0 orders_bench.ix[0] = 1000 #orders_bench.ix[-1] = 0 orders_bench = orders_bench[(orders_bench != 0).any(axis=1)] portvals_bench = ms.compute_portvals(df_trades = orders_bench,\ start_val = sv) if isinstance(portvals_bench, pd.DataFrame): portvals_bench = portvals_bench[ portvals_bench.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" if chart: prices = ind.normalize(prices) portvals = ind.normalize(portvals) portvals_bench = ind.normalize(portvals_bench) strat_portvals = ind.normalize(strat_portvals) title = name + ":Manual vs. Strategy vs. Benchmark" f = portvals.plot(title = title, linewidth=1.0,\ label='Manual', color='black') f.set_xlabel("Date") f.set_ylabel("Value") plt.grid(True) portvals_bench.plot(ax=f, linewidth=1.0, legend=True,\ label='Benchmark', color='blue') strat_portvals.plot(ax=f, linewidth=1.0, legend=True, label='Strat', color='red') f.legend(loc='upper left', prop={'size': 5}) #f2 = f.twinx() #prices.plot(ax=f2, linewidth=0.7, label = 'Prices', color='r') #f2.set_ylabel('Prices') #f2.legend(loc='upper right', prop={'size':5}) #for index, row in orders.iterrows(): # if row.values[0] == 1000: # plt.axvline(x=index, color='g', linestyle='--', lw=0.7, linewidth=0.3) # if row.values[0] == -1000: # plt.axvline(x=index, color='r', linestyle='--', lw=0.7, linewidth=0.3) plt.savefig(name) # Get portfolio stats start_date = portvals.index.min() end_date = portvals.index.max() cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench \ = ms.compute_portfolio_stats(portvals_bench) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio \ = ms.compute_portfolio_stats(portvals) s_cum_ret, s_avg_daily_ret, s_std_daily_ret, s_sharpe_ratio \ = ms.compute_portfolio_stats(strat_portvals) # Compare portfolio against $SPX print "Date Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Manual: {}".format(sharpe_ratio) print "Sharpe Ratio of Bench : {}".format(sharpe_ratio_bench) print "Sharpe Ratio of Strat : {}".format(s_sharpe_ratio) print print "Cumulative Return of Manual: {}".format(cum_ret) print "Cumulative Return of Bench : {}".format(cum_ret_bench) print "Cumulative Return of Strat: {}".format(s_cum_ret) print print "Standard Deviation of Manual: {}".format(std_daily_ret) print "Standard Deviation of Bench: {}".format(std_daily_ret_bench) print "Standard Deviation of Strat: {}".format(s_std_daily_ret) print print "Average Daily Return of Manual: {}".format(avg_daily_ret) print "Average Daily Return of Bench: {}".format(avg_daily_ret_bench) print "Average Daily Return of Strat: {}".format(s_avg_daily_ret) print print "Final Portfolio Value of Manual: {}".format(portvals[-1]) print "Final Portfolio Value of Bench: {}".format(portvals_bench[-1]) print "Final Portfolio Value of Strat: {}".format(strat_portvals[-1])
def test_code(): # In Sample - Portfolio df_trades = testPolicy() portvals = ms.compute_portvals(df_trades, start_val=100000, commission=9.95, impact=0.005) if isinstance(portvals, pd.DataFrame): portvals = portvals[ portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" # Benchmark Portfolio df_benchmark = pd.DataFrame(index=df_trades.index, columns=["JPM"]) df_benchmark.loc[df_trades.index] = 0 df_benchmark.loc[df_trades.index[0]] = 1000 # Buying 1000 shares of JPM portvals_benchmark = ms.compute_portvals(df_benchmark, start_val=100000, commission=9.95, impact=0.005) # Normalize Portfolio and Benchmark Portfolio portvals_norm = portvals / portvals.iloc[0] portvals_benchmark = portvals_benchmark / portvals_benchmark.iloc[0] # Generate Plot - In Sample figure, axis = plt.subplots() portvals_norm.plot(ax=axis, color='r') portvals_benchmark.plot(ax=axis, color='g') plt.title("Comparison of Manual Strategy Portfolio vs Benchmark") plt.legend(["Manual Strategy", "Benchmark"]) plt.xlabel("Date") plt.ylabel("Normalized Portfolio Value") for date, trade in df_trades.iterrows(): if trade["JPM"] < 0: plt.axvline(x=date, color='k') elif trade["JPM"] > 0: plt.axvline(x=date, color='b') plt.savefig("ManualStrategy-InSample.png") # plt.show() # Out Sample - Portfolio symbol = "JPM" sd = dt.datetime(2010, 1, 1) ed = dt.datetime(2011, 12, 31) df_trades_os = testPolicy(symbol, sd, ed) portvals_os = ms.compute_portvals(df_trades_os, start_val=100000, commission=9.95, impact=0.005) # Benchmark Portfolio - Out Sample df_benchmark_os = pd.DataFrame(index=df_trades_os.index, columns=["JPM"]) df_benchmark_os.loc[df_trades_os.index] = 0 df_benchmark_os.loc[df_trades_os.index[0]] = 1000 # Buying 1000 shares of JPM portvals_benchmark_os = ms.compute_portvals(df_benchmark_os, start_val=100000, commission=9.95, impact=0.005) # Normalize Portfolio and Benchmark Portfolio portvals_norm_os = portvals_os / portvals_os.iloc[0] portvals_benchmark_os = portvals_benchmark_os / portvals_benchmark_os.iloc[0] # Generate Plot - Out Sample figure, axis = plt.subplots() portvals_norm_os.plot(ax=axis, color='r') portvals_benchmark_os.plot(ax=axis, color='g') plt.title("Comparison of Manual Strategy Portfolio vs Benchmark - Out of Sample") plt.legend(["Manual Strategy", "Benchmark"]) plt.xlabel("Date") plt.ylabel("Normalized Portfolio Value") plt.savefig("ManualStrategy-OutSample.png") # plt.show() # Display Portfolio Stats portvals_os = portvals_os[portvals_os.columns[0]] # In - Sample Stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats(portvals) # print(cumulative_return, avg_daily_ret, std_daily_ret, sharpe_ratio) cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = \ ms.compute_portfolio_stats(portvals_benchmark[portvals_benchmark.columns[0]]) print(f"Sharpe Ratio of Fund (In-Sample): {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark (In-Sample): {sharpe_ratio_bench}") print() print(f"Cumulative Return of Fund (In-Sample): {cum_ret}") print(f"Cumulative Return of Benchmark (In-Sample): {cum_ret_bench}") print() print(f"Standard Deviation of Fund (In-Sample): {std_daily_ret}") print(f"Standard Deviation of Benchmark (In-Sample): {std_daily_ret_bench}") print() print(f"Average Daily Return of Fund (In-Sample): {avg_daily_ret}") print(f"Average Daily Return of Benchmark (In-Sample): {avg_daily_ret_bench}") print() print(f"Final Portfolio Value: {portvals[-1]}") print() # Out-Sample Stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats(portvals_os) cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = \ ms.compute_portfolio_stats(portvals_benchmark[portvals_benchmark_os.columns[0]]) print(f"Sharpe Ratio of Fund (Out-Sample): {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark (Out-Sample): {sharpe_ratio_bench}") print() print(f"Cumulative Return of Fund (Out-Sample): {cum_ret}") print(f"Cumulative Return of Benchmark (Out-Sample): {cum_ret_bench}") print() print(f"Standard Deviation of Fund (Out-Sample): {std_daily_ret}") print(f"Standard Deviation of Benchmark (Out-Sample): {std_daily_ret_bench}") print() print(f"Average Daily Return of Fund (Out-Sample): {avg_daily_ret}") print(f"Average Daily Return of Benchmark (Out-Sample): {avg_daily_ret_bench}") print() print(f"Final Portfolio Value: {portvals_os[-1]}")
def main(): start_date = '2003-1-1' end_date = '2004-12-31' symbols = 'NFLX' ms = ManualStrategy() # df_trades = ms.testPolicy(symbols, start_date, end_date, 100000) # port_vals = compute_portvals(orders=df_trades, start_val=100000, commission=9.95, impact=0.005) df_bchm = ms.benchMark(symbols, start_date, end_date, 100000) port_vals_bchm = compute_portvals(orders=df_bchm, start_val=100000, commission=9.95, impact=0.005) # print port_vals, port_vals_bchm # cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats(port_vals) cum_ret_bchm, avg_daily_ret_bchm, std_daily_ret_bchm, sharpe_ratio_bchm = compute_portfolio_stats( port_vals_bchm) # Compare portfolio against $SPX print "Date Range(Out of Sample): {} to {}".format(start_date, end_date) print # print "Out of Sample Cumulative Return of Portfolio: {}".format(cum_ret) print "Out of Sample Cumulative Return of Benchmark: {}".format( cum_ret_bchm) print # print "Out of Sample Standard Deviation of Portfolio: {}".format(std_daily_ret) print "Out of Sample Deviation of Benchmark: {}".format(std_daily_ret_bchm) print # print "Out of Sample Average Daily Return of Portfolio: {}".format(avg_daily_ret) print "Out of Sample Average Daily Return of Benchmark: {}".format( avg_daily_ret_bchm) print #print "Out of Sample Sharpe Ratio of Portfolio: {}".format(sharpe_ratio) print "Out of Sample Sharpe Ratio of Benchmark: {}".format( sharpe_ratio_bchm) print #print "Out of Sample Final Portfolio Value: {}".format(port_vals[-1]) print "Out of Sample Final Benchmark Value: {}".format(port_vals_bchm[-1]) port_vals_bchm_norm = port_vals_bchm / port_vals_bchm.ix[0, ] #port_vals_norm = port_vals / port_vals.ix[0,] port_vals_bchm_norm.to_csv(path='first.csv') port_vals_bchm_norm = port_vals_bchm_norm.to_frame() #port_vals_norm = port_vals_norm.to_frame() f3 = plt.figure(3) re = port_vals_bchm_norm.join(port_vals_norm, lsuffix='_benchmark', rsuffix='_portfolio') re.columns = ['Benchmark', 'Value of the best possible portfolio'] ax = re.plot( title= "Normalized Benchmark and Value of The Best Possible Portfolio(Out of Sample)", fontsize=12, color=["blue", "black"]) ax.set_xlabel("Date") ax.set_ylabel("Portfolio") # f2.show() plt.show()
first_plot.set_xlim(date_min, date_max) second_plot = benchmark_value_norm.plot(grid=True, title='Best Possible Strategy', use_index=True, color='blue') second_plot.xaxis.set_major_locator(matplot_dates.MonthLocator()) second_plot.xaxis.set_major_formatter(matplot_dates.DateFormatter('%b')) second_plot.xaxis.set_minor_locator(matplot_dates.YearLocator()) second_plot.xaxis.set_minor_formatter(matplot_dates.DateFormatter('%Y')) second_plot.xaxis.set_tick_params(which='minor', pad=20) second_plot.set_xlabel("Date") second_plot.set_ylabel("Normalized Stock Price") second_plot.set_xlim(date_min, date_max) plt.legend(('Portfolio Value', 'Benchmark'), loc='best', prop={'size': 12}) plt.savefig('Best Possible Strategy.png') plt.clf() plt.cla() plt.close() print "NORMALIZED IN SAMPLE" cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats(portfolio_value_norm) cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = ms.compute_portfolio_stats(benchmark_value_norm) print "Sharpe Ratio of Portfolio: " + str(sharpe_ratio) print "Sharpe Ratio of Benchmark : " + str(sharpe_ratio_bench) print print "Cumulative Return of Portfolio: " + str(cum_ret) print "Cumulative Return of Benchmark: " + str(cum_ret_bench) print print "Standard Deviation of Portfolio: " + str(std_daily_ret) print "Standard Deviation of Benchmark: " + str(std_daily_ret_bench) print print "Average Daily Return of Portfolio: " + str(avg_daily_ret) print "Average Daily Return of Benchmark: " + str(avg_daily_ret_bench)
def Exp2Main(sd = dt.datetime(2008,1,1), ed = dt.datetime(2009,12,31), start_money = 100000,commission = 9.95): # setting the random seed np.random.seed(1234) #Strategy Learner sl_impact_low = sl.StrategyLearner(verbose=False, impact=0.0001) sl_impact_low.add_evidence(symbol='JPM', sd=sd, ed=ed, sv=start_money) df_trades_impact_low = sl_impact_low.testPolicy(symbol='JPM', sd=sd, ed=ed, sv=start_money) portvals_impact_low = mk.compute_portvals(orders_file = df_trades_impact_low, start_val=start_money, commission=commission, impact=0.0001) sl_impact_med= sl.StrategyLearner(verbose=False, impact=0.001) sl_impact_med.add_evidence(symbol='JPM', sd=sd, ed=ed, sv=start_money) df_trades_impact_med = sl_impact_med.testPolicy(symbol='JPM', sd=sd, ed=ed, sv=start_money) portvals_impact_med = mk.compute_portvals(orders_file = df_trades_impact_med, start_val=start_money, commission=commission, impact=0.001) sl_impact_high = sl.StrategyLearner(verbose=False, impact=0.01) sl_impact_high.add_evidence(symbol='JPM', sd=sd, ed=ed, sv=start_money) df_trades_impact_high = sl_impact_high.testPolicy(symbol='JPM', sd=sd, ed=ed, sv=start_money) portvals_impact_high = mk.compute_portvals(orders_file = df_trades_impact_high, start_val=start_money, commission=commission, impact=0.01) print('Strategy learner: portvals_impact_low') print(portvals_impact_low) print('================') print('Strategy learner: portvals_impact_med') print(portvals_impact_med) print('================') print('Strategy learner: portvals_impact_high') print(portvals_impact_high) print('================') # calculate: Cumulative return of the benchmark and portfolio # Stdev of daily returns of benchmark and portfolio # Mean of daily returns of benchmark and portfolio cum_ret_1, avg_daily_ret_1, std_daily_ret_1, sharpe_ratio_1 = mk.compute_portfolio_stats(portvals_impact_low) cum_ret_2, avg_daily_ret_2, std_daily_ret_2, sharpe_ratio_2 = mk.compute_portfolio_stats(portvals_impact_med) cum_ret_3, avg_daily_ret_3, std_daily_ret_3, sharpe_ratio_3 = mk.compute_portfolio_stats(portvals_impact_high) # 4. Compare portfolio against Benchmark print() print() print('================') print(f"Date Range: {sd} to {ed}") print() print(f"Sharpe Ratio of Fund impact = 0.0001 : {sharpe_ratio_1}") print(f"Sharpe Ratio of Fund impact = 0.001 : {sharpe_ratio_2}") print(f"Sharpe Ratio of Fund impact = 0.01: {sharpe_ratio_3}") print() print(f"Cumulative Return of Fund impact = 0.0001: {cum_ret_1}") print(f"Cumulative Return of Fund impact = 0.001 : {cum_ret_2}") print(f"Cumulative Return of Fund impact = 0.01 : {cum_ret_3}") print() print(f"Standard Deviation of Fund impact = 0.0001: {std_daily_ret_1}") print(f"Standard Deviation of Fund impact = 0.001 : {std_daily_ret_2}") print(f"Standard Deviation of Fund impact = 0.01 : {std_daily_ret_3}") print() print(f"Average Daily Return of Fund impact = 0.0001: {avg_daily_ret_1}") print(f"Average Daily Return of Fund impact = 0.001 : {avg_daily_ret_2}") print(f"Average Daily Return of Fund impact = 0.01 : {avg_daily_ret_3}") # 5.Plot #Normalize the value port_vals_1_norm = _normalize(portvals_impact_low) port_vals_2_norm = _normalize(portvals_impact_med) port_vals_3_norm = _normalize(portvals_impact_high) port_vals_1_norm= port_vals_1_norm.to_frame() port_vals_2_norm= port_vals_2_norm.to_frame() port_vals_3_norm= port_vals_3_norm.to_frame() # f=plt.figure(figsize=(20,10)) plt.gca() port_line1, = plt.plot(port_vals_1_norm, color = 'red',label = 'impact = 0.0001' ) port_line2, = plt.plot(port_vals_2_norm, color = 'blue',label = 'impact = 0.001') port_line3, = plt.plot(port_vals_3_norm, color = 'green',label = 'impact = 0.01') plt.legend(fontsize='15') plt.xlabel("Date",fontsize='15') plt.xticks(fontsize='14',rotation=30) plt.ylabel("Portfolio",fontsize='15') plt.title("Performance of Strategy Learner in different impact values",fontsize='15') # f.show() plt.savefig('StrategyLearner_impact_comparison.png',bbox_inches='tight') plt.close()
def test_code(): # Set Seed to have consistency across runs np.random.seed(902831571) # In - Sample Dates sd = dt.datetime(2008, 1, 1) ed = dt.datetime(2009, 12, 31) symbol = 'JPM' syms = [symbol] dates = pd.date_range(sd, ed) prices_all = ut.get_data(syms, dates) # automatically adds SPY prices = prices_all[syms] # only portfolio symbols prices_SPY = prices_all['SPY'] # only SPY, for comparison later # Manual Strategy Learner ms_trades = mans.testPolicy(symbol, sd, ed, sv=100000) ms_portvals = ms.compute_portvals(ms_trades, start_val=100000, commission=9.95, impact=0.005) # Benchmark Portfolio df_benchmark = pd.DataFrame(index=ms_trades.index, columns=["JPM"]) df_benchmark.loc[ms_trades.index] = 0 df_benchmark.loc[ms_trades.index[0]] = 1000 # Buying 1000 shares of JPM portvals_benchmark = ms.compute_portvals(df_benchmark, start_val=100000, commission=9.95, impact=0.005) # Strategy Learner strat_learner = sl.StrategyLearner(verbose=False, impact=0.005) strat_learner.addEvidence(symbol, sd, ed, sv=100000) df_trades = strat_learner.testPolicy(symbol, sd, ed, sv=100000) strat_portvals = ms.compute_portvals(df_trades, start_val=100000, commission=9.95, impact=0.005) # Normalize Portfolios ms_portvals_norm = ms_portvals / ms_portvals.iloc[0] strat_portvals_norm = strat_portvals / strat_portvals.iloc[0] portvals_benchmark_norm = portvals_benchmark / portvals_benchmark.iloc[0] # Generate Plot - In Sample figure, axis = plt.subplots() ms_portvals_norm.plot(ax=axis, color='r') portvals_benchmark_norm.plot(ax=axis, color='g') strat_portvals_norm.plot(ax=axis, color='b') plt.title("Portfolio Comparisons of Strategies") plt.legend(["Manual Strategy", "Benchmark", "Strategy Learner"]) plt.xlabel("Date") plt.ylabel("Normalized Portfolio Value") # for date, trade in df_trades.iterrows(): # if trade["JPM"] < 0: # plt.axvline(x=date, color='k') # elif trade["JPM"] > 0: # plt.axvline(x=date, color='b') plt.savefig("experiment1.png") # plt.show() # In - Sample Stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats( ms_portvals[ms_portvals.columns[0]]) cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = \ ms.compute_portfolio_stats(portvals_benchmark[portvals_benchmark.columns[0]]) cum_ret_strat, avg_daily_ret_strat, std_daily_ret_strat, sharpe_ratio_strat = \ ms.compute_portfolio_stats(strat_portvals[strat_portvals.columns[0]]) print( f"Sharpe Ratio of Strategy Learner (In-Sample): {sharpe_ratio_strat}") print(f"Sharpe Ratio of Manual Strategy (In-Sample): {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark (In-Sample): {sharpe_ratio_bench}") print() print( f"Cumulative Return of Strategy Learner (In-Sample): {cum_ret_strat}") print(f"Cumulative Return of Manual Strategy (In-Sample): {cum_ret}") print(f"Cumulative Return of Benchmark (In-Sample): {cum_ret_bench}") print() print( f"Standard Deviation of Strategy Learner (In-Sample): {std_daily_ret_strat}" ) print( f"Standard Deviation of Manual Strategy (In-Sample): {std_daily_ret}") print( f"Standard Deviation of Benchmark (In-Sample): {std_daily_ret_bench}") print() print( f"Average Daily Return of Strategy Learner (In-Sample): {avg_daily_ret_strat}" ) print( f"Average Daily Return of Manual Strategy (In-Sample): {avg_daily_ret}" ) print( f"Average Daily Return of Benchmark (In-Sample): {avg_daily_ret_bench}" ) print()
def generate_second_plot(): start_date = dt.datetime(2008, 1, 1) end_date = dt.datetime(2009, 12, 31) dates = pd.date_range(start_date, end_date) df = get_data(stock_ticker, dates) df.fillna(method='ffill', inplace=True) df.fillna(method='bfill', inplace=True) pd.set_option('chained_assignment', None) start_value = 100000 trades_df = testPolicy(symbol="JPM", sd=start_date, ed=end_date, sv=start_value) portfolio_value = ms.compute_portvals(trades_df, start_val=start_value, commission=9.95, impact=0.005) portfolio_value.fillna(method='ffill', inplace=True) portfolio_value.fillna(method='bfill', inplace=True) portfolio_value_norm = portfolio_value / portfolio_value.ix[0, :] trades_df_benchmark = testPolicyBenchmark(symbol="JPM", sd=start_date, ed=end_date, sv=start_value) benchmark_value = ms.compute_portvals(trades_df_benchmark, start_val=start_value, commission=9.95, impact=0.005) benchmark_value.fillna(method='ffill', inplace=True) benchmark_value.fillna(method='bfill', inplace=True) benchmark_value_norm = benchmark_value / benchmark_value.ix[0, :] first_plot = portfolio_value_norm.plot(grid=True, title='Manual Strategy In-Sample', use_index=True, color='black') assign_plot_labels(trades_df, first_plot) second_plot = benchmark_value_norm.plot(grid=True, title='', use_index=True, color='blue') assign_plot_labels(trades_df, second_plot) for index, row in trades_df.iterrows(): if row['Order'] == 'BUY': plt.axvline(x=index, color='g', linestyle='-') elif row['Order'] == 'SELL': plt.axvline(x=index, color='r', linestyle='-') plt.legend(('Portfolio Value', 'Benchmark'), loc='best', prop={'size': 12}) plt.savefig('Manual Strategy In-Sample.png') plt.clf() plt.cla() plt.close() print "IN-SAMPLE" cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats( portfolio_value_norm) cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench = ms.compute_portfolio_stats( benchmark_value_norm) print "Sharpe Ratio of Portfolio: " + str(sharpe_ratio) print "Sharpe Ratio of Benchmark : " + str(sharpe_ratio_bench) print print "Cumulative Return of Portfolio: " + str(cum_ret) print "Cumulative Return of Benchmark: " + str(cum_ret_bench) print print "Standard Deviation of Portfolio: " + str(std_daily_ret) print "Standard Deviation of Benchmark: " + str(std_daily_ret_bench) print print "Average Daily Return of Portfolio: " + str(avg_daily_ret) print "Average Daily Return of Benchmark: " + str(avg_daily_ret_bench)
f1 = chart_df.plot(grid=True, title='Manual Strategy vs Strategy Learner', use_index=True, color=['Black', 'Blue', 'Green']) f1.xaxis.set_major_locator(mdates.MonthLocator()) f1.xaxis.set_major_formatter(mdates.DateFormatter('%b')) f1.xaxis.set_minor_locator(mdates.YearLocator()) f1.xaxis.set_minor_formatter(mdates.DateFormatter('%Y')) f1.xaxis.set_tick_params(which='minor', pad=10) datemin = dt.date(normed_prices_benchmark.index.min().year, 1, 1) datemax = dt.date(normed_prices_benchmark.index.max().year + 1, 1, 1) f1.set_xlabel("Time (Date)") f1.set_ylabel("Normalized Portfolio Value") f1.set_xlim(datemin, datemax) cum_ret_sl, avg_daily_ret_sl, std_daily_ret_sl, sharpe_ratio_sl = msc.compute_portfolio_stats( normed_prices_sl) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = msc.compute_portfolio_stats( normed_prices_ms) cum_ret_bmk, avg_daily_ret_bmk, std_daily_ret_bmk, sharpe_ratio_bmk = msc.compute_portfolio_stats( normed_prices_benchmark) print "Sharpe Ratio Strategy Learner:{}".format(sharpe_ratio_sl) print "Sharpe Ratio Manual Strategy:{}".format(sharpe_ratio) print "Sharpe Ratio Benchmark:{}".format(sharpe_ratio_bmk) print "Cum Return Strategy Learner:{}".format(cum_ret_sl) print "Cum Return Manual Strategy:{}".format(cum_ret) print "Cum Return Benchmark:{}".format(cum_ret_bmk) print "Std Dev Strategy Learner:{}".format(std_daily_ret_sl) print "Std Dev Manual Strategy:{}".format(std_daily_ret) print "Std Dev Benchmark:{}".format(std_daily_ret_bmk)
def addEvidence(self, symbol="IBM", sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 12, 31), sv=10000): """Creates a QLearner, and trains it for trading. Inputs / Parameters: symbol: The stock symbol to act on sd: A datetime object that represents the start date ed: A datetime object that represents the end date sv: Start value of the portfolio which contains only the one symbol """ # Get adjusted close prices for the given symbol on the given date range dates = pd.date_range(sd, ed) prices_all = get_data([symbol], dates) #includes SPY due to util function pricesDF = prices_all[[symbol]] # only the symbol # Get features and thresholds indicatorsDF = self.getIndicators(pricesDF[symbol]) thresholds = self.setThresholds(indicatorsDF, self.num_steps) cum_returns = [] for epoch in range(1, self.epochs + 1): # Initial position is holding nothing position = self.CASH # Create a series that captures order signals based on actions taken orders = pd.Series(index=indicatorsDF.index) # Iterate over the data by date for day, date in enumerate(indicatorsDF.index): # Get a state state = self.getState(indicatorsDF.loc[date], thresholds) # On the first day, get an action without updating the Q-table if date == indicatorsDF.index[0]: action = self.QLearner.querysetstate(state) newPos = float(action - 1) # On other days, calculate the reward and update the Q-table else: prev_price = pricesDF[symbol].iloc[day - 1] curr_price = pricesDF[symbol].loc[date] reward = self.calcDailyReward(prev_price,curr_price, position) action = self.QLearner.query(state, reward) newPos = float(action - 1) # Add new_pos to orders, update current position orders.loc[date] = newPos position = newPos #get the portfolio values (which also creates the tradesDF and pricesDF, in the background portvals, tradesDF, holdingsDF, pricesDF = marketsimcode.compute_portvals_single_stock(ordersDF=orders, symbol=symbol, start_val=sv, commission=self.commission, impact=self.impact, num_shares = self.num_shares) cum_return = marketsimcode.compute_portfolio_stats(portvals)[0] cum_returns.append(cum_return) # Check for convergence after running for at least 30 epochs if epoch > 20: # Stop if the cum_return doesn't improve for 10 epochs if self.checkConvergence(cum_returns): break #print "orders series from learner", orders #print "tradesDF from learner: ", tradesDF if self.verbose: plt.plot(cum_returns) plt.xlabel("Epoch") plt.ylabel("Cumulative return (%)") # plt.show() plt.savefig('result.png') plt.switch_backend('Agg')
def main(): start_date = '2008-1-1' end_date = '2009-12-31' start_money = 100000 symbols = 'JPM' tos = TheoreticallyOptimalStrategy() # 1. Run the testPolicy for symbol XXX df_trades = tos.testPolicy(symbols, start_date, end_date, start_money) port_vals = mk.compute_portvals(orders_file=df_trades, start_val=start_money, commission=0.00, impact=0.00) # print('port_vals') # print(port_vals) # 2. Run the benchmark df_bchm = tos.benchMark(symbols, start_date, end_date, start_money) port_vals_bench = mk.compute_portvals(orders_file=df_bchm, start_val=start_money, commission=0.00, impact=0.00) print() print() print('================') # print('port_vals_bench') # print(port_vals_bench) # 3. calculate: Cumulative return of the benchmark and portfolio # Stdev of daily returns of benchmark and portfolio # Mean of daily returns of benchmark and portfolio cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = mk.compute_portfolio_stats( port_vals) cum_ret_b, avg_daily_ret_b, std_daily_ret_b, sharpe_ratio_b = mk.compute_portfolio_stats( port_vals_bench) # 4. Compare portfolio against Benchmark print() print() print('================') print(f"Date Range: {start_date} to {end_date}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print(f"Sharpe Ratio of Benchmark : {sharpe_ratio_b}") print() print(f"Cumulative Return of Fund: {cum_ret}") print(f"Cumulative Return of Benchmark : {cum_ret_b}") print() print(f"Standard Deviation of Fund: {std_daily_ret}") print(f"Standard Deviation of Benchmark : {std_daily_ret_b}") print() print(f"Average Daily Return of Fund: {avg_daily_ret}") print(f"Average Daily Return of Benchmark : {avg_daily_ret_b}") # 5.Plot port_vals_norm = port_vals / port_vals.iloc[0] port_vals_norm = port_vals_norm.to_frame() port_vals_bench_norm = port_vals_bench / port_vals_bench.iloc[0] port_vals_bench_norm = port_vals_bench_norm.to_frame() f = plt.figure(figsize=(20, 10)) plt.gca() port_line = plt.plot(port_vals_norm, color='red', label='Theoretically Optimal Strategy') bench_line = plt.plot(port_vals_bench_norm, color='green', label='Benchmark') plt.xlabel("Date", fontsize='15') plt.ylabel("Portfolio", fontsize='15') plt.title( "Normalized Benchmark and Value of Theoretically Optimal Strategy", fontsize='15') f.show() plt.savefig('Tos_vs_Benchmark.png', bbox_inches='tight')
def testCode(sym, sd=dt.datetime(2010,1,1), ed=dt.datetime(2011,12,31), sv=100000,\ chart = False): # Best Possible Order orders = testPolicy(sym=sym, sd=sd, ed=ed, sv = sv) #orders = orders[(orders != 0).any(axis=1)] portvals = ms.compute_portvals(df_trades = orders, start_val = sv, commission=0,\ impact=0) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" #print orders # Benchmark orders_bench = orders.copy() orders_bench.ix[1:-1,:] = 0 orders_bench.ix[0] = 1000 #print orders_bench orders_bench = orders_bench[(orders_bench!=0).any(axis=1)] #print orders portvals_bench = ms.compute_portvals(df_trades = orders_bench,\ start_val = sv, commission=0, impact=0) if isinstance(portvals_bench, pd.DataFrame): portvals_bench = portvals_bench[portvals_bench.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" if chart: portvals = ind.normalize(portvals) portvals_bench = ind.normalize(portvals_bench) f = portvals.plot(title = "Best Possible vs. Benchmark", linewidth=1.5,\ label='Best_Possible', color='black', style='-') f.set_xlabel("Date") f.set_ylabel("Value") plt.grid(True) portvals_bench.plot(ax=f, linewidth=1.5, legend=True,\ label='Benchmark', color='blue', style='--') f.legend(loc='best', prop={'size':10}) plt.savefig("Best_Possible") # Get portfolio stats start_date = portvals.index.min() end_date = portvals.index.max() cum_ret_bench, avg_daily_ret_bench, std_daily_ret_bench, sharpe_ratio_bench \ = ms.compute_portfolio_stats(portvals_bench) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio \ = ms.compute_portfolio_stats(portvals) # Compare portfolio against $SPX print "Date Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Best: {}".format(sharpe_ratio) print "Sharpe Ratio of Bench : {}".format(sharpe_ratio_bench) print print "Cumulative Return of Best: {}".format(cum_ret) print "Cumulative Return of Bench : {}".format(cum_ret_bench) print print "Standard Deviation of Best: {}".format(std_daily_ret) print "Standard Deviation of Bench: {}".format(std_daily_ret_bench) print print "Average Daily Return of Best: {}".format(avg_daily_ret) print "Average Daily Return of Bench : {}".format(avg_daily_ret_bench) print print "Final Portfolio Value of Best: {}".format(portvals[-1]) print "Final Portfolio Value of Bench: {}".format(portvals_bench[-1])
def test_code(): sd = dt.datetime(2008, 1, 1) ed = dt.datetime(2009, 12, 31) sv = 100000 df_trades = testPolicy(symbol="JPM", sd=sd, ed=ed, sv=sv) portvals = ms.compute_portvals(df_trades, start_val=sv) syms = ['SPY'] dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) # automatically adds SPY prices_SPY = prices_all['SPY'] # only SPY, for comparison later prices_SPY_normalized = normalize_stocks(prices_SPY) prices_portval_normalized = normalize_stocks(portvals) chart_df = pd.concat([prices_portval_normalized, prices_SPY_normalized], axis=1) chart_df.columns = ['Portfolio', 'Benchmark'] chart_df.plot(grid=True, title='Comparing Manual strategy with Benchmark index', use_index=True, color=['Black', 'Blue']) for index, row in df_trades.iterrows(): if df_trades.loc[index]['Order'] == 'BUY': plt.axvline(x=index, color='g', linestyle='-') elif df_trades.loc[index]['Order'] == 'SELL': plt.axvline(x=index, color='r', linestyle='-') cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats( portvals) cum_ret_SPY, avg_daily_ret_SPY, std_daily_ret_SPY, sharpe_ratio_SPY = ms.compute_portfolio_stats( prices_SPY) print('In Sample stats:') print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of SPY : {}".format(sharpe_ratio_SPY) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of SPY : {}".format(cum_ret_SPY) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of SPY : {}".format(std_daily_ret_SPY) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of SPY : {}".format(avg_daily_ret_SPY) print print "Final Portfolio Value: {}".format(portvals[-1]) print('Out of Sample Stats:') sd = dt.datetime(2010, 1, 1) ed = dt.datetime(2011, 12, 31) sv = 100000 df_trades = testPolicy(symbol="JPM", sd=sd, ed=ed, sv=sv) portvals = ms.compute_portvals(df_trades, start_val=sv) syms = ['SPY'] dates = pd.date_range(sd, ed) prices_all = get_data(syms, dates) # automatically adds SPY prices_SPY = prices_all['SPY'] # only SPY, for comparison later prices_SPY_normalized = normalize_stocks(prices_SPY) prices_portval_normalized = normalize_stocks(portvals) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = ms.compute_portfolio_stats( portvals) cum_ret_SPY, avg_daily_ret_SPY, std_daily_ret_SPY, sharpe_ratio_SPY = ms.compute_portfolio_stats( prices_SPY) chart_df = pd.concat([prices_portval_normalized, prices_SPY_normalized], axis=1) chart_df.columns = ['Portfolio', 'Benchmark'] chart_df.plot( grid=True, title='Comparing Manual strategy with Benchmark index Out of Sample', use_index=True, color=['Black', 'Blue']) print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of SPY : {}".format(sharpe_ratio_SPY) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of SPY : {}".format(cum_ret_SPY) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of SPY : {}".format(std_daily_ret_SPY) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of SPY : {}".format(avg_daily_ret_SPY) print print "Final Portfolio Value: {}".format(portvals[-1]) plt.show()
def test_code(): # Set Seed to have consistency across runs np.random.seed(902831571) # In - Sample Dates sd = dt.datetime(2008, 1, 1) ed = dt.datetime(2009, 12, 31) symbol = 'JPM' syms = [symbol] dates = pd.date_range(sd, ed) prices_all = ut.get_data(syms, dates) # automatically adds SPY prices = prices_all[syms] # only portfolio symbols prices_SPY = prices_all['SPY'] # only SPY, for comparison later # Strategy Learner (Impact = 0) strat_learner = sl.StrategyLearner(verbose=False, impact=0) strat_learner.addEvidence(symbol, sd, ed, sv=100000) df_trades = strat_learner.testPolicy(symbol, sd, ed, sv=100000) strat_portvals_zero = ms.compute_portvals(df_trades, start_val=100000, commission=0, impact=0) # Strategy Learner (Impact = 0.005) strat_learner = sl.StrategyLearner(verbose=False, impact=0.005) strat_learner.addEvidence(symbol, sd, ed, sv=100000) df_trades = strat_learner.testPolicy(symbol, sd, ed, sv=100000) strat_portvals_imp1 = ms.compute_portvals(df_trades, start_val=100000, commission=0, impact=0.005) # Strategy Learner (Impact = 0.01) strat_learner = sl.StrategyLearner(verbose=False, impact=0.01) strat_learner.addEvidence(symbol, sd, ed, sv=100000) df_trades = strat_learner.testPolicy(symbol, sd, ed, sv=100000) strat_portvals_imp2 = ms.compute_portvals(df_trades, start_val=100000, commission=0, impact=0.01) # Normalize Portfolios strat_portvals_zero_norm = strat_portvals_zero / strat_portvals_zero.iloc[0] strat_portvals_imp1_norm = strat_portvals_imp1 / strat_portvals_imp1.iloc[0] strat_portvals_imp2_norm = strat_portvals_imp2 / strat_portvals_imp2.iloc[0] # Generate Plots figure, axis = plt.subplots() strat_portvals_zero_norm.plot(ax=axis, color='r') strat_portvals_imp1_norm.plot(ax=axis, color='g') strat_portvals_imp2_norm.plot(ax=axis, color='b') plt.title("Portfolio Comparisons of Strategy Learner") plt.legend(["Impact = 0", "Impact = 0.05", "Impact = 0.01"]) plt.xlabel("Date") plt.ylabel("Normalized Portfolio Value") plt.savefig("experiment2.png") # plt.show() # Statistics cum_ret_zero, avg_daily_ret_zero, std_daily_ret_zero, sharpe_ratio_zero = ms.compute_portfolio_stats( strat_portvals_zero[strat_portvals_zero.columns[0]]) cum_ret_imp1, avg_daily_ret_imp1, std_daily_ret_imp1, sharpe_ratio_imp1 = \ ms.compute_portfolio_stats(strat_portvals_imp1[strat_portvals_imp1.columns[0]]) cum_ret_imp2, avg_daily_ret_imp2, std_daily_ret_imp2, sharpe_ratio_imp2 = \ ms.compute_portfolio_stats(strat_portvals_imp2[strat_portvals_imp2.columns[0]]) print(f"Sharpe Ratio of Strategy Learner (Impact = 0): {sharpe_ratio_zero}") print(f"Sharpe Ratio of Manual Strategy (Impact = 0.005): {sharpe_ratio_imp1}") print(f"Sharpe Ratio of Benchmark (Impact = 0.01): {sharpe_ratio_imp2}") print() print(f"Cumulative Return of Strategy Learner (Impact = 0): {cum_ret_zero}") print(f"Cumulative Return of Manual Strategy (Impact = 0.005): {cum_ret_imp1}") print(f"Cumulative Return of Benchmark (Impact = 0.01): {cum_ret_imp2}") print()
bench_in = pd.DataFrame(bench_in) port_out = compute_portvals(symbol, df_trades_out, c0) port_out = pd.DataFrame(port_out) bench_out = compute_portvals(symbol, benchmark_out, c0) bench_out = pd.DataFrame(bench_out) # Calculate cumulative returns port_ret_in = float(np.asarray(port_in.values)[-1]) port_ret_out = float(np.asarray(port_out.values)[-1]) bench_ret_in = float(np.asarray(bench_in.values)[-1]) bench_ret_out = float(np.asarray(bench_out.values)[-1]) ''' # Calculate cumulative returns port_ret_in = ms.compute_portfolio_stats(port_in)[0] port_ret_out = ms.compute_portfolio_stats(port_out)[0] bench_ret_in = ms.compute_portfolio_stats(bench_in)[0] bench_ret_out = ms.compute_portfolio_stats(bench_out)[0] # Print results print print 'Cumulative return in-sample:\t\t${:,.2f}\t\t(+{:.2f} %)'.format( port_ret_in, 100 * (port_ret_in - c0) / c0) print 'Benchmark return in-sample:\t\t\t${:,.2f}\t\t(+{:.2f} %)'.format( bench_ret_in, 100 * (bench_ret_in - c0) / c0) print 'Cumulative return out-of-sample:\t${:,.2f}\t\t(+{:.2f} %)'.format( port_ret_out, 100 * (port_ret_out - c0) / c0) print 'Benchmark return out-of-sample:\t\t${:,.2f}\t\t(+{:.2f} %)'.format( bench_ret_out, 100 * (bench_ret_out - c0) / c0)
def Exp1Main(sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 12, 31), start_money=100000, impact=0.005, commission=9.95): # setting the random seed np.random.seed(1234) # Manual Strategy manu = ms.ManualStrategy(verbose=False, impact=impact, commission=commission) df_trades = manu.testPolicy(symbol="JPM", sd=sd, ed=ed, sv=start_money) port_vals = mk.compute_portvals(orders_file=df_trades, start_val=start_money, commission=commission, impact=impact) # Strategy Learner slearner = sl.StrategyLearner(verbose=False, impact=impact, commission=commission) slearner.add_evidence(symbol="JPM", sd=sd, ed=ed, sv=start_money) df_trades_sl = slearner.testPolicy(symbol='JPM', sd=sd, ed=ed, sv=start_money) port_vals_strategy = mk.compute_portvals(orders_file=df_trades_sl, start_val=start_money, commission=commission, impact=impact) # Benchmark df_bchm = manu.benchMark(symbol="JPM", sd=sd, ed=ed, sv=start_money) port_vals_bench = mk.compute_portvals(orders_file=df_bchm, start_val=start_money, commission=commission, impact=impact) print('Manual strategy: port_vals') print(port_vals) print('================') print('Strategy strategy: port_vals_strategy') print(port_vals_strategy) print('================') print('Benchmark normalized: port_vals_bench') print(port_vals_bench) # calculate: Cumulative return of the benchmark and portfolio # Stdev of daily returns of benchmark and portfolio # Mean of daily returns of benchmark and portfolio cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = mk.compute_portfolio_stats( port_vals) cum_ret_sl, avg_daily_ret_sl, std_daily_ret_sl, sharpe_ratio_sl = mk.compute_portfolio_stats( port_vals_strategy) cum_ret_b, avg_daily_ret_b, std_daily_ret_b, sharpe_ratio_b = mk.compute_portfolio_stats( port_vals_bench) # 4. Compare portfolio against Benchmark print() print() print('================') print(f"Date Range: {sd} to {ed}") print() print(f"Sharpe Ratio of Fund: {sharpe_ratio}") print(f"Sharpe Ratio of Strategy : {sharpe_ratio_sl}") print(f"Sharpe Ratio of Benchmark : {sharpe_ratio_b}") print() print(f"Cumulative Return of Fund: {cum_ret}") print(f"Cumulative Return of Strategy : {cum_ret_sl}") print(f"Cumulative Return of Benchmark : {cum_ret_b}") print() print(f"Standard Deviation of Fund: {std_daily_ret}") print(f"Standard Deviation of Strategy : {std_daily_ret_sl}") print(f"Standard Deviation of Benchmark : {std_daily_ret_b}") print() print(f"Average Daily Return of Fund: {avg_daily_ret}") print(f"Average Daily Return of Strategy : {avg_daily_ret_sl}") print(f"Average Daily Return of Benchmark : {avg_daily_ret_b}") # 5.Plot #Normalize the value port_vals_norm = _normalize(port_vals) port_vals_strategy_norm = _normalize(port_vals_strategy) port_vals_bench_norm = _normalize(port_vals_bench) port_vals_norm = port_vals_norm.to_frame() port_vals_strategy_norm = port_vals_strategy_norm.to_frame() port_vals_bench_norm = port_vals_bench_norm.to_frame() f = plt.figure(figsize=(20, 10)) plt.gca() port_line, = plt.plot(port_vals_norm, color='red', label='Manual Strategy') strategy_line, = plt.plot(port_vals_strategy_norm, color='blue', label='Strategy Learner') bench_line, = plt.plot(port_vals_bench_norm, color='green', label='Benchmark') plt.legend(fontsize='15') plt.xlabel("Date", fontsize='15') plt.xticks(fontsize='14', rotation=30) plt.ylabel("Portfolio", fontsize='15') plt.title("Normalized Benchmark vs. Manual Strategy vs. Strategy Learner", fontsize='15') # f.show() plt.savefig('ManualStrategy_vs_StrategyLearner_vs_Benchmark.png', bbox_inches='tight') plt.close()