def build_stochastic_oscillator(symbols, start_date, end_date, windows, start_val): dates = pd.date_range(start_date, end_date) prices_all = get_data([symbols], dates) # automatically adds SPY prices = prices_all[symbols] # only portfolio symbols SPY_prices = prices_all['SPY'] ema_fast = pd.ewma(prices, span=n_fast, min_periods=n_slow - 1) ema_slow = pd.ewma(prices, span=n_slow, min_periods=n_slow - 1) macd = ema_fast - ema_slow macd_signal = pd.ewma(macd, span=9, min_periods=8) macd_hist = macd - macd_signal macd_df = pd.DataFrame(macd, columns=['MACD']) macd_df['Signal'] = macd_signal macd_df.dropna() plot_macd_strategy(macd_df, macd_hist, prices, symbols) df_portfolio = pd.DataFrame(SPY_prices) df_portfolio['Bollinger Strategy'] = compute_portvals( start_date, end_date, 'orders.txt', start_val) df_portfolio['MACD'] = compute_portvals(start_date, end_date, filename, start_val) plot_normalized_data(df_portfolio)
def plot_Q6(pv_rule): pv_ml = compute_portvals("test_order_Q6.csv", start_val=START_CASH) bm_df = compute_portvals("bm_order_out.csv", start_val=START_CASH) tmp_df = pd.DataFrame(index=bm_df.index) tmp_df['BM'] = bm_df tmp_df['pv_rule'] = pv_rule tmp_df['pv_ml'] = pv_ml tmp_df = tmp_df.fillna(method='bfill') tmp_df = tmp_df.fillna(method='ffill') tmp_df_norm = tmp_df / tmp_df.ix[0] ax = tmp_df_norm['BM'].plot(label='benchmark', color='k') tmp_df_norm['pv_ml'].plot(ax=ax, label='ML strategy', color='g') tmp_df_norm['pv_rule'].plot(ax=ax, label='Manual strategy', color='b') plt.title("Out-of-Sample Performance ", color='m') plt.ylabel("Normalised Price") plt.legend(loc='best') plt.show() print "\n" cr_bm, adr_bm, sddr_bm, sr_bm = get_portfolio_stats(tmp_df['BM'], verbose=True, title='Benchmark') cr, adr, sddr, sr = get_portfolio_stats( tmp_df['pv_ml'], verbose=True, title='Out-of-Sample : ML Strategy') cr, adr, sddr, sr = get_portfolio_stats( tmp_df['pv_rule'], verbose=True, title='Out-of-Sample : Manual Strategy')
def createMACD(symbols, start_date, end_date, n_fast, n_slow, start_val): dates = pd.date_range(start_date, end_date) prices_all = get_data([symbols], dates) # automatically adds SPY prices = prices_all[symbols] # only portfolio symbols SPY_prices = prices_all['SPY'] emaSlow = pd.ewma(prices, span=n_slow, min_periods = n_slow - 1) emaFast = pd.ewma(prices, span=n_fast, min_periods = n_slow - 1) macdInitial = emaFast - emaSlow macdSignal = pd.ewma(macdInitial, span=9, min_periods = 8) macdHist = macdInitial - macdSignal macdDF = pd.DataFrame(macdInitial, columns=['MACD']) macdDF['Signal'] = macdSignal macdDF = macdDF.dropna() displayMACD(macdDF, symbols) df_portfolio = pd.DataFrame(SPY_prices) df_portfolio['Bollinger Bounds'] = compute_portvals(start_date, end_date, 'orders.txt', start_val) df_portfolio['My Strategy'] = compute_portvals(start_date, end_date, myFile, start_val) plot_normalized_data(df_portfolio)
def simulate_orders(symbols,orders_files = ["./orders_rule.csv"], start_val = 100000, labels=["Manual rule based","benchmark"],strategy=["Manual rule based"], start_date="2008-01-01",end_date="2009-12-31",benchmark=True, benchmark_date="2008-01-02",bm_filename="benchmark_orders",two_strategy=False, legend_loc="lower right",title="title", entry_line=0,savefig="Fig.png"): origin_portvals=compute_portvals(orders_files[0] , start_val,start_date=start_date,end_date=end_date) #normalize portvals portvals=origin_portvals/origin_portvals.ix[0] start_date = dt.date.strftime(portvals.index[0],"%Y-%m-%d") end_date = dt.date.strftime(portvals.index[-1],"%Y-%m-%d") print "Date Range: {} to {}".format(start_date, end_date) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = compute_portfolio_stats(portvals) print "Cumulative Return of {}: {}".format(strategy[0],cum_ret.values[0]) print "Standard Deviation of daily return of {}: {}".format(strategy[0],std_daily_ret.values[0]) print "Average Daily Return of {}: {}".format(strategy[0],avg_daily_ret.values[0]) ax1=portvals.plot(title=title) ax1.set_ylabel("Normalized Price") ax1.set_xlabel("Date") if benchmark: origin_benchmark_portvals=benchmark_portforlio(symbol=symbols[0],date=benchmark_date,start_date=start_date,end_date=end_date,filename=bm_filename) benchmark_portvals=origin_benchmark_portvals/origin_benchmark_portvals.ix[0] cum_ret_BM, avg_daily_ret_BM, std_daily_ret_BM, sharpe_ratio_BM = compute_portfolio_stats(benchmark_portvals) print "Cumulative Return of Benchmark : {}".format(cum_ret_BM.values[0]) print "Standard Deviation of daily return of Benchmark : {}".format(std_daily_ret_BM.values[0]) print "Average Daily Return of Benchmark : {}".format(avg_daily_ret_BM.values[0]) benchmark_portvals.plot(ax=ax1,color="black") if two_strategy: origin_portvals2=compute_portvals(orders_files[1] , start_val,start_date=start_date,end_date=end_date) #normalize portvals portvals2=origin_portvals2/origin_portvals2.ix[0] cum_ret2, avg_daily_ret2, std_daily_ret2, sharpe_ratio2 = compute_portfolio_stats(portvals2) print "Cumulative Return of {}: {}".format(strategy[1],cum_ret2.values[0]) print "Standard Deviation of daily return of {}: {}".format(strategy[1],std_daily_ret2.values[0]) print "Average Daily Return of {}: {}".format(strategy[1],avg_daily_ret2.values[0]) portvals2.plot(ax=ax1,color="g") if entry_line>=0: ymin, ymax = ax1.get_ylim() orders=pd.read_csv(orders_files[entry_line]) for i in range(0,len(orders),2): if orders.ix[i,"Order"]=="SELL": ax1.axvline(pd.to_datetime(orders.ix[i,"Date"]),ymin=0,ymax=ymax,color="r") else: ax1.axvline(pd.to_datetime(orders.ix[i,"Date"]),ymin=0,ymax=ymax,color="g") plt.legend(loc=legend_loc,prop={'size':8},labels=labels) plt.savefig(savefig) plt.close()
def experiment2(sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 12, 31), symbol="JPM", sv=100000, impact=0.000, commission=0, graphnum=1): manual_trades = ms.testPolicy(symbol=symbol, sd=sd, ed=ed) # manual_count = manual_trades.astype(bool).sum(axis=0) # print "Number of trades in the Manual Strategy is:", manual_count learner = sl.StrategyLearner(verbose=False, impact=impact) learner.addEvidence(symbol=symbol, sd=sd, ed=ed, sv=sv) sl_trades = learner.testPolicy(symbol=symbol, sd=sd, ed=ed, sv=sv) strategy_count = sl_trades.astype(bool).sum(axis=0) print "Number of trades in the Strategy Learner is:", strategy_count manual_portval = mksim.compute_portvals(manual_trades, start_val=sv, commission=commission, impact=impact) # m_cr, m_adr, m_ssdr, m_sr = mksim.compute_portfolio_stats(manual_portval) # print "Cumulative Return of the Manual Strategy is:", m_cr sl_portval = mksim.compute_portvals(sl_trades, start_val=sv, commission=commission, impact=impact) sl_cr, sl_adr, sl_ssdr, sl_sr = mksim.compute_portfolio_stats(sl_portval) print "Cumulative Return of the Strategy Learner is:", sl_cr benchmark_trades = manual_trades.copy() benchmark_trades[:] = 0 benchmark_trades.ix[0, 0] = 1000 benchmark_trades.ix[-1, 0] = -1000 benchmark_portvals = mksim.compute_portvals(benchmark_trades, start_val=sv, commission=commission, impact=impact) plot_df = manual_trades.copy() plot_df['Manual Strategy'] = manual_portval[0:] / manual_portval.ix[0] plot_df['Strategy Learner'] = sl_portval[0:] / sl_portval.ix[0] plot_df['Benchmark'] = benchmark_portvals[0:] / benchmark_portvals.ix[0] plot_df = plot_df.drop(plot_df.columns[0], axis=1) ax = plot_df.plot(title="Stock Prices", color=['b', 'k', 'r']) ax.set_xlabel("Date") ax.set_ylabel("Normalized Portfolio Return for In-Sample Data") plt.savefig("exp2_graph_{}".format(str(graphnum))) plt.clf()
def test_orders_short(self): tests = [{'filename': './orders/orders-short.csv', 'start_val':1000000, 'final_val':998035.0, 'cr':-0.001965, 'adr':-0.000178539446839, 'sdr':0.00634128215394, 'sr':-0.446948390642}, {'filename': './orders/orders.csv', 'start_val':1000000, 'final_val':1133860.0, 'cr':0.13386, 'adr':0.000551651296638, 'sdr':0.00720514136323, 'sr':1.21540888742}, {'filename': './orders/orders2.csv', 'start_val':1000000, 'final_val':1078752.6, 'cr':0.0787526, 'adr':0.000353426354584, 'sdr':0.00711102080156, 'sr':0.788982285751}, {'filename': './orders/orders3.csv', 'start_val':1000000, 'final_val':1050160.0, 'cr':0.05016, 'adr':0.000365289198877, 'sdr':0.00560508094997, 'sr':1.03455887842}, {'filename': './orders/orders-leverage-1.csv', 'start_val':1000000, 'final_val':1050160.0, 'cr':0.05016, 'adr':0.000487052265169, 'sdr':0.00647534272091, 'sr':1.19402406143}, {'filename': './orders/orders-leverage-2.csv', 'start_val':1000000, 'final_val':1074650.0, 'cr':0.07465, 'adr':0.00202241842159, 'sdr':0.00651837064888, 'sr':4.92529481246},] for i, test in enumerate(tests): portvals = m.compute_portvals(orders_file = test['filename'], start_val = test['start_val']) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # just get the first column else: "warning, code did not return a DataFrame" print "portfolio_values", type(portvals) print portvals.shape cr, adr, sdr, sr = m.compute_portfolio_stats(portvals) np.testing.assert_almost_equal(portvals.ix[-1], test['final_val'], decimal=1) np.testing.assert_almost_equal(cr, test['cr'], decimal = 4) np.testing.assert_almost_equal(adr, test['adr'], decimal = 4) np.testing.assert_almost_equal(sdr, test['sdr'], decimal = 4) np.testing.assert_almost_equal(sr, test['sr'], decimal = 4) print "test", i, "passes"
def optimize_in_sample_port(): """ This function performs grid search to find optimum values for rolling_days and k !!!!!!!!!!!!!!!!! not yet finale! """ sd = dt.datetime(2008, 1, 1) ed = dt.datetime(2009, 12, 31) sv = 100000 fin_val = [[]] rd = 0 for i in range(0, 20): k = 0.0 rd = rd + 2 for j in range(0, 6): k = k + 0.5 df_trades = testPolicy(symbol="JPM", sd=sd, ed=ed, sv=sv, rolling_days=rd, k=k) portvals = ms.compute_portvals(df_trades, start_val=sv) fin_val[i, j] = portvals[-1]
def optimize_in_sample_port(n_trials=30, period=1): """ This function returns number of rooling days that gives max finale port_value """ sd = dt.datetime(2008, 1, 1) ed = dt.datetime(2009, 12, 31) sv = 100000 fin_val = [] rd_vals = [] rd = 0 for i in range(0, n_trials): rd = rd + period df_trades = testPolicy(symbol="JPM", sd=sd, ed=ed, sv=sv, rolling_days=rd) portvals = ms.compute_portvals(df_trades, start_val=sv) fin_val.append(portvals[-1]) rd_vals.append(rd) index = np.argmax(fin_val) opt_rd = rd_vals[index] return opt_rd
def test_run(): of = "./orders/orders2.csv" sv = 1000000 portvals = compute_portvals(orders_file=of, start_val=sv) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] cr, adr, sdr, sr, port_val, start_dates, end_dates = compute_portfolio_stats( portvals) cr_SPY, adr_SPY, sdr_SPY, sr_SPY, spy_value, start_dates, end_dates = compute_portfolio_stats( get_data(['SPY'], dates=pd.date_range(start_dates, end_dates))) # Compare portfolio against $SPX print print "Date Range: {} to {}".format(start_dates, end_dates) print print "Sharpe Ratio of Fund: {}".format(sr) print "Sharpe Ratio of SPY : {}".format(sr_SPY) print print "Cumulative Return of Fund: {}".format(cr) print "Cumulative Return of SPY : {}".format(cr_SPY) print print "Standard Deviation of Fund: {}".format(sdr) print "Standard Deviation of SPY : {}".format(sdr_SPY) print print "Average Daily Return of Fund: {}".format(adr) print "Average Daily Return of SPY : {}".format(adr_SPY) print print "Final Portfolio Value: {}".format(portvals[-1]) if of == "./orders/orders.csv": print "Portfolio Value of orders: 1133860.0" if of == "./orders/orders2.csv": print "Portfolio Value of orders2: 1078752.6" if of == "./orders/orders3.csv": print "Portfolio Value of orders3: 1050160.0"
def simulateOrders(start_date, end_date, orders_file, start_val): # Process orders portvals = compute_portvals(start_date, end_date, orders_file, start_val) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date)) prices_SPX = prices_SPX[['$SPX']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) # Compare portfolio against $SPX print "Data Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1]) # Plot computed daily portfolio value df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', 'SPY'], axis=1) plot_normalized_data(df_temp, title="Daily portfolio value")
def test_orders_leverage_1(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-leverage-1.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1050160.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 106 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 1.19402406143 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.05016 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00647534272091 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.000487052265169 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_leverage(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-leverage.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1087919.23 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 232 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 0.449503553356 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.08791923 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0196343644101 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.0005559678854 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_11(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-11.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1078670.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 37 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 3.28377563093 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.07867 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0104365693923 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.00215889226484 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def create_rule_based_portfolio(syms, start_date, end_date, initial_cash, look_back): """ @summary: runs manual trading strategy and calculates its' daily value. @param syms: List of stock symbols to be included in strategy. @param start_date: Start date of trading. @param end_date: End date of trading. @param initial_cash: Amount of cash available to use for trading. @param look_back: Look back period for indicator analysis @return rule_portfolio: Portfolio's daily value in dataframe @return orders: Dataframe consisting of orders for dates that have orders. """ orders = run_rule_based_strategy(syms=syms, start_date=start_date, end_date=end_date, look_back=look_back) rule_based_orders = './orders/rule_based.csv' ut.write_orders_to_csv(orders, rule_based_orders) rule_portfolio = marketsim.compute_portvals(orders_file=rule_based_orders, start_val=initial_cash) rule_portfolio = rule_portfolio[rule_portfolio.columns[0]] rule_portfolio = ut.standardise_timeperiod(rule_portfolio, start_date, end_date, initial_cash) rule_portfolio.rename('Rule-based portfolio', inplace=True) return rule_portfolio, orders
def test_orders_07(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-07.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1106563.3 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 237 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 2.10356512897 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.1065633 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00327897532471 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.0004345040621 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def run(): #Training start_date = '2008-1-1' end_date = '2009-12-31' #Testing # start_date='2010-1-1' # end_date='2011-12-31' stock = 'JPM' dates = pd.date_range(start_date, end_date) prices_all = get_data([stock], dates) indicators(prices_all, dates, stock) compute_portvals("./orders/my_strategy.csv", prices_all, dates, stock)
def test_orders_leverage_2(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-leverage-2.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1074650.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 37 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 4.92529481246 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.07465 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00651837064888 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.00202241842159 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_01(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-01.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1115569.2 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 245 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 0.612340613407 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.1155692 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0142680745065 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.00055037432146 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_leverage_4(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-leverage-4.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 998035.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 11 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = -0.446948390642 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = -0.001965 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00634128215394 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = -0.000178539446839 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_04(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-04.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 923545.4 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 233 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = -0.266030146916 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = -0.0764546 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0143332213612 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = -0.000240200768212 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_03(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-03.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 857616.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 240 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = -0.759896272199 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = -0.142384 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0119352106704 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = -0.000571326189931 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_06(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-06.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 894604.3 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 210 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = -1.23463930987 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = -0.1053957 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00657385746675 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = -0.000511281541086 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_05(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-05.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1415563.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 296 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 2.19591520826 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.415563 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00880023087527 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.00121733290744 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def check_leverage(self, name, filename, start_val, last_day_portval): print name portvals = compute_portvals(orders_file=filename, start_val=start_val) portvals = portvals[portvals.columns[0]] np.testing.assert_allclose([last_day_portval], [portvals[-1]], rtol=0.001)
def test_orders_09(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-09.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1067710.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 37 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 2.90848480553 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.06771 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.0102202265027 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.00187252252117 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def test_orders_10(self): portvals = marketsim.compute_portvals( orders_file="./orders/orders-10.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1050160.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format( final_portfolio_value, expected_value), delta=None) expected_value = 141 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}". format(final_portfolio_dataframe_length, expected_value)) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats( portvals) if success: expected_value = 1.03455887842 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format( sharpe_ratio[0], expected_value), delta=None) expected_value = 0.05016 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format( cum_ret[0], expected_value), delta=None) expected_value = 0.00560508094997 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format( std_daily_ret[0], expected_value), delta=None) expected_value = 0.000365289198877 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format( avg_daily_ret[0], expected_value), delta=None)
def experiment1(sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 12, 31), symbol="JPM", sv=100000, impact=0, commission=0): manual_trades = ms.testPolicy(symbol=symbol, sd=sd, ed=ed) learner = sl.StrategyLearner(verbose=False, impact=impact) learner.addEvidence(symbol=symbol, sd=sd, ed=ed, sv=sv) sl_trades = learner.testPolicy(symbol=symbol, sd=sd, ed=ed, sv=sv) manual_portval = mksim.compute_portvals(manual_trades, start_val=sv, commission=commission, impact=impact) sl_portval = mksim.compute_portvals(sl_trades, start_val=sv, commission=commission, impact=impact) benchmark_trades = manual_trades.copy() benchmark_trades[:] = 0 benchmark_trades.ix[0, 0] = 1000 benchmark_trades.ix[-1, 0] = -1000 benchmark_portvals = mksim.compute_portvals(benchmark_trades, start_val=sv, commission=commission, impact=impact) plot_df = manual_trades.copy() plot_df['Manual Strategy'] = manual_portval[0:] / manual_portval.ix[0] plot_df['Strategy Learner'] = sl_portval[0:] / sl_portval.ix[0] plot_df['Benchmark'] = benchmark_portvals[0:] / benchmark_portvals.ix[0] plot_df = plot_df.drop(plot_df.columns[0], axis=1) # print plot_df ax = plot_df.plot(title="Stock Prices", color=['b', 'k', 'r']) ax.set_xlabel("Date") ax.set_ylabel("Normalized Portfolio Return for In-Sample Data") plt.savefig("exp1_graph1") plt.clf()
def check_no_leverage(self, name, filename, start_val, num_days, last_day_portval, sharpe_ratio, avg_daily_ret): print name portvals = compute_portvals(orders_file=filename, start_val=start_val) portvals = portvals[portvals.columns[0]] days = len(portvals) cr, adr, sddr, sr = compute_portfolio_stats(portvals) np.testing.assert_allclose( [num_days, last_day_portval, sharpe_ratio, avg_daily_ret], [days, portvals[-1], sr, adr], rtol=0.001)
def test_run(): symbols = ['IBM'] train_dates = pd.date_range('2008-1-1', '2010-12-31') test_dates = pd.date_range('2011-1-1', '2011-12-31') training = get_data(symbols, train_dates) testing = get_data(symbols, test_dates) trainingIBM = training[symbols] testingIBM = testing[symbols] testing_result = train_model(trainingIBM, testingIBM) ax = testing_result[['IBM', 'pred']].plot(title='Predicted market') ax.set_xlabel('Date') ax.set_ylabel('Price') fig = ax.get_figure() fig.savefig("output/predicted_market.png") generate_orders(testing_result) orders_file = os.path.join("orders", "orders.csv") start_val = 10000 # Process orders portvals = compute_portvals('2011-1-1', '2011-12-31', orders_file, start_val) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series # print portvals # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['$SPX'], test_dates) prices_SPX = prices_SPX[['$SPX']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) print "Data Range: {} to {}".format('2011-1-1', '2011-12-31') print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1]) # Plot computed daily portfolio value df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', '$SPX'], axis=1) plot_normalized_data(df_temp, title="Daily portfolio value and $SPX")
def Q6(symbols=['AAPL'], lookback=14): sd = DT.datetime(2010, 01, 01) ed = DT.datetime(2011, 12, 31) df = get_features(sd, ed, symbols) df = df.fillna(method='bfill') df['signal'] = 'NADA' df['action'] = 'NADA' orders_df = build_orders_v1(df, lookback) orders_df.to_csv("rule_based_orders_out.csv", index_label='Date') port_df_out = compute_portvals("rule_based_orders_out.csv", start_val=START_CASH) plot_Q6(port_df_out)
def main(gen_plot=False): of = "benchmark.csv" sv = 100000 #Get Technical Values from indicators file normalAverage, bollBand, MACDInd,momentum,prices = indicators.plotIndicators(gen_plot=gen_plot) orders = ordersFile(normalAverage=normalAverage, bollBand=bollBand, MACDInd=MACDInd, momentum=momentum) # Process orders portvals = marketsim.compute_portvals(orders_file=of, start_val=sv) #Print statements to determine start and end value print portvals.head(1) print portvals.tail(1) of = "orders.csv" #default name of file is orders.csv portvals1 = marketsim.compute_portvals(orders_file=of, start_val=sv) print portvals1.head(1) print portvals1.tail(1) if gen_plot: df = pd.concat([portvals/portvals.iloc[0], portvals1/portvals1.iloc[0]], keys=['Benchmark', 'Rule-Based'], axis=1) ax = df.plot(title="Rule Based Trader", fontsize=12,color=["Black","Blue"]) ax.set_xlabel("Date") ax.set_ylabel("Price Normalized") stock = 0 #Loop through orders to add vertical lines for date,order in orders.iterrows(): if order.loc["Order"]=="SELL": stock-=500 if stock==0: ax.axvline(date.date(),color="Black") else: ax.axvline(date.date(), color="Red") else: stock+=500 if stock==0: ax.axvline(date.date(),color="Black") else: ax.axvline(date.date(), color="Green") plt.show()
def create_optimal_portfolio(stock, sv, start_date, end_date): orders = determine_optimal_orders(stock=stock, start_date=start_date, end_date=end_date) optimal_orders = './orders/optimal_orders.csv' ut.write_orders_to_csv(orders, optimal_orders) # Calculate portfolio: optimal_portfolio = marketsim.compute_portvals(orders_file=optimal_orders, start_val=sv) optimal_portfolio = optimal_portfolio[optimal_portfolio.columns[0]] return optimal_portfolio
def test_run(): start_date = '2007-12-31' end_date = '2009-12-31' symbols = ['IBM'] generate_orders(start_date, end_date, symbols) orders_file = os.path.join("orders", "orders.csv") start_val = 10000 # Process orders portvals = compute_portvals(start_date, end_date, orders_file, start_val) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # if a DataFrame is returned select the first column to get a Series # print portvals # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date)) prices_SPX = prices_SPX[['$SPX']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) print "Data Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1]) # Plot computed daily portfolio value df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', '$SPX'], axis=1) plot_normalized_data(df_temp, title="Daily portfolio value and $SPX")
def test_orders_leverage_1(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-leverage-1.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(1050160.0, final_portfolio_value, 4, "Final portfolio value is {} incorrect".format(final_portfolio_value), delta=None) self.assertEqual(106, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = 1.19402406143 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = 0.05016 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00647534272091 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = 0.000487052265169 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders2(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders2.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(1078752.6, final_portfolio_value, 4, "Final portfolio value {} is incorrect".format(final_portfolio_value), delta=None) self.assertEqual(232, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = 0.788982285751 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = 0.0787526 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00711102080156 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = 0.000353426354584 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(1133860.0, final_portfolio_value, 4, "Final portfolio value {} is incorrect".format(final_portfolio_value), delta=None) self.assertEqual(240, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = 1.21540888742 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = 0.13386 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00720514136323 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = 0.000551651296638 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders_short(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-short.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(998035.0, final_portfolio_value, 4, "Final portfolio value {} is incorrect".format(final_portfolio_value), delta=None) self.assertEqual(11, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = -0.446948390642 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = -0.001965 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00634128215394 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = -0.000178539446839 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders_leverage_3(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-leverage-3.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(1050160.0, final_portfolio_value, 4, "Final portfolio value is {} incorrect".format(final_portfolio_value), delta=None) self.assertEqual(141, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = 1.03455887842 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = 0.05016 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00560508094997 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = 0.000365289198877 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg dailt return {} is incorrect. Expected".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders_leverage_2(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-leverage-2.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:][0] final_portfolio_dataframe_length = len(portvals) self.assertAlmostEqual(1074650.0, final_portfolio_value, 4, "Final portfolio value is {} incorrect".format(final_portfolio_value), delta=None) self.assertEqual(37, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect".format(final_portfolio_dataframe_length)) cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) expected_value = 4.92529481246 self.assertAlmostEqual(expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None) expected_value = 0.07465 self.assertAlmostEqual(expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None) expected_value = 0.00651837064888 self.assertAlmostEqual(expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None) expected_value = 0.00202241842159 self.assertAlmostEqual(expected_value, avg_daily_ret[0], 4, "Avg dailt return {} is incorrect. Expected".format(avg_daily_ret[0], expected_value), delta=None) '''
def test_orders08(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-08.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1074884.1 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 229 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 0.941858298061 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.0748841 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.00560508094997 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.000365289198877 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_05(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-05.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1415563.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 296 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 2.19591520826 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.415563 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.00880023087527 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.00121733290744 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_leverage(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-leverage.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:] self.assertAlmostEqual(1087919.23, final_portfolio_value, 4, "Final portfolio value is {} incorrect".format(final_portfolio_value), delta=None)
def test_run(): """Driver function.""" # Define input parameters start_date = '2007-12-31' end_date = '2009-12-31' orders_file = os.path.join("orders", "current_order.csv") dates = pd.date_range(start_date, end_date) symbols = ['IBM'] df = get_data(symbols, dates, True) window_size = 20 sma_band, upper_band, lower_band = get_bands(df['IBM'],window=window_size) #+1 going out, -1 coming in transition_array_upper = np.pad(np.diff(np.array(df['IBM'] > upper_band).astype(int)), (1,0), 'constant', constant_values = (0,)) #+2 stock price going up,-2 stock price going down transition_array_sma = np.pad(np.diff(np.array(df['IBM'] > sma_band).astype(int)*2), (1,0), 'constant', constant_values = (0,)) #+3 stock price going up from lower_band,-3 stock price going down from lower_band transition_array_lower = np.pad(np.diff(np.array(df['IBM'] > lower_band).astype(int)*3), (1,0), 'constant', constant_values = (0,)) write_orders(df,transition_array_upper,transition_array_sma,transition_array_lower, orders_file) ax = df['IBM'].plot(title="Bollinger Bands", label='IBM') sma_band.plot(label='SMA', ax=ax, color = 'Goldenrod') upper_band.plot(label='Upper Bollinger Band', ax=ax, color = 'Turquoise') lower_band.plot(label='Lower Bollinger Band', ax=ax, color = 'Turquoise') ax.set_xlabel("Date") ax.set_ylabel("Price") ax.legend(loc='upper left') plt.show() portvals = compute_portvals(start_date, end_date, orders_file, 10000) # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date)) prices_SPX = prices_SPX[['$SPX']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) # Compare portfolio against $SPX print "Data Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1]) # Plot computed daily portfolio value df_temp = pd.concat([portvals, prices_SPX['$SPX']], keys=['Portfolio', 'SPY'], axis=1) plot_normalized_data(df_temp, title="Daily portfolio value")
def test_orders_12(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-12.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1050160.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 240 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 0.792286003513 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.05016 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.00428731360634 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.00021397693658 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_leverage(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-leverage.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1087919.23 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 232 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 0.449503553356 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.08791923 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0196343644101 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.0005559678854 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_01(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-01.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1115569.2 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 245 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 0.612340613407 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.1155692 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0142680745065 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.00055037432146 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_03(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-03.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 857616.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 240 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = -0.759896272199 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = -0.142384 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0119352106704 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = -0.000571326189931 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_04(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-04.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 923545.4 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 233 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = -0.266030146916 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = -0.0764546 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0143332213612 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = -0.000240200768212 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
last_day = last_day[["index"]] last_day.columns = ["Date"] last_day["Symbol"] = "IBM" last_day["Order"] = last_action last_day["Shares"] = 500 orders = orders.append(last_day).reset_index(drop = True) # write orders to csv orders.to_csv("Machine_Learning_based_orders.csv",index = None) print(orders) # compute portfolio values ml_based_values = compute_portvals("Machine_Learning_based_orders.csv",100000) train['ML_Based_Value'] = ml_based_values train['Buy_Hold_Value'] = train.IBM * 500 + (100000 - train.IBM[0] * 500) train['Norm_ML_Based_Value'] = train.ML_Based_Value / train.ML_Based_Value[0] train['Norm_Benchmark'] = train.Buy_Hold_Value / train.Buy_Hold_Value[0] buys = orders[orders.Order == "BUY"].Date sells = orders[orders.Order == "SELL"].Date # generate performance plot df_ML_Based_Value = train[["Norm_Benchmark","Norm_ML_Based_Value"]] plt.figure()
def test_run(): """Driver function.""" # Define input parameters start_date = '2007-12-31' end_date = '2009-12-31' stock_symbol = ["IBM"] #initial cash for the strategy start_val = 10000 #Get stock quotation dates = pd.date_range(start_date, end_date) stock_prices = get_data(stock_symbol, dates) #Get bollinger indicator and trading signals bollinger = bollinger_indicator(stock_prices[ stock_symbol[0] ]) trading_signal = bollinger_strategy( bollinger ) #Get orders and save to csv order file orders = generate_trades(stock_symbol[0], start_val, bollinger, trading_signal) orders_file = os.path.join("orders", "bollinger.csv") orders.to_csv(orders_file, index=False) #Plot strategy plot_bollinger_strategy( bollinger, trading_signal ) #Measure performance of strategy #Process orders portvals = marketsim.compute_portvals(start_date, end_date, orders_file, start_val) portvals = portvals[ "_VALUE" ] # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['^GSPC'], pd.date_range(start_date, end_date)) prices_SPX = prices_SPX[['^GSPC']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) # Compare portfolio against $SPX print "Data Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1]) # Plot computed daily portfolio value df_temp = pd.concat([portvals, prices_SPX['^GSPC']], keys=['Portfolio', '^GSPC'], axis=1) plot_normalized_data(df_temp, title="Daily portfolio value and $SPX")
def test_orders_07(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-07.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1106563.3 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 237 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 2.10356512897 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.1065633 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.00327897532471 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.0004345040621 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_short(self): portvals = marketsim.compute_portvals(orders_file = "./orders/orders-short.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1,:] self.assertAlmostEqual(998035.0, final_portfolio_value, 4, "Final portfolio value {} is incorrect".format(final_portfolio_value), delta=None)
def test_run(): """Driver function.""" # Define input parameters start_date = '2007-12-31' end_date = '2009-12-31' symbol = 'IBM' dates = pd.date_range(start_date, end_date) prices_all = get_data([symbol], dates) prices = prices_all[symbol] # Compute Bollinger Bands rm = get_rolling_mean(prices, window=20) rstd = get_rolling_std(prices, window=20) upper_band, lower_band = get_bollinger_bands(rm, rstd) # Find Bollinger strategy orders df_orders = get_orders_bollinger(symbol, prices, rm, upper_band, lower_band, window=20) # Plot raw values, rolling mean and Bollinger Bands plot_data_bollinger(symbol, prices, rm, upper_band, lower_band, df_orders) #orders_file = os.path.join(".\orders", "orders-short.csv") with open('orders3.csv', 'wb') as outfile: writer = csv.writer(outfile, delimiter=',') writer.writerow(['Date', 'Symbol', 'Order', 'Shares']) for i in range(len(df_orders)): writer.writerow([df_orders.ix[i,0].strftime('%Y-%m-%d'), df_orders.ix[i,1], df_orders.ix[i,2], df_orders.ix[i,3]]) ########################################################################### orders_file = os.path.join("orders3.csv") start_val = 10000 # Process orders portvals = compute_portvals(start_date, end_date, orders_file, start_val) if isinstance(portvals, pd.DataFrame): portvals = portvals[portvals.columns[0]] # Get portfolio stats cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(portvals) # Simulate a $SPX-only reference portfolio to get stats prices_SPX = get_data(['$SPX'], pd.date_range(start_date, end_date)) prices_SPX = prices_SPX[['$SPX']] # remove SPY portvals_SPX = get_portfolio_value(prices_SPX, [1.0]) cum_ret_SPX, avg_daily_ret_SPX, std_daily_ret_SPX, sharpe_ratio_SPX = get_portfolio_stats(portvals_SPX) # Compare portfolio against $SPX print "Data Range: {} to {}".format(start_date, end_date) print print "Sharpe Ratio of Fund: {}".format(sharpe_ratio) print "Sharpe Ratio of $SPX: {}".format(sharpe_ratio_SPX) print print "Cumulative Return of Fund: {}".format(cum_ret) print "Cumulative Return of $SPX: {}".format(cum_ret_SPX) print print "Standard Deviation of Fund: {}".format(std_daily_ret) print "Standard Deviation of $SPX: {}".format(std_daily_ret_SPX) print print "Average Daily Return of Fund: {}".format(avg_daily_ret) print "Average Daily Return of $SPX: {}".format(avg_daily_ret_SPX) print print "Final Portfolio Value: {}".format(portvals[-1])
def my_strategy_IBM(prices, predicted_prices, start_date, end_date, file, titl): ax = prices.plot(title=titl, label="price") orders = [] red_flag = 0 green_flag = 0 counter = 0 for index, row in prices.iterrows(): change = predicted_prices["Predicted Y"].ix[index] - prices["Price"].ix[index] p_change = (change / prices["Price"].ix[index]) * 100.0 if p_change > 1.0 and green_flag == 0 and red_flag == 0: plt.axvline(index, color="green") orders.append([index.strftime("%Y-%m-%d"), "IBM", "BUY", 100]) green_flag = 1 elif p_change < -1.0 and red_flag == 0 and green_flag == 0: plt.axvline(index, color="red") orders.append([index.strftime("%Y-%m-%d"), "IBM", "SELL", 100]) red_flag = 1 if counter == 5: plt.axvline(index, color="black") if red_flag == 1: orders.append([index.strftime("%Y-%m-%d"), "IBM", "BUY", 100]) red_flag = 0 elif green_flag == 1: orders.append([index.strftime("%Y-%m-%d"), "IBM", "SELL", 100]) green_flag = 0 counter = 0 elif red_flag == 1 or green_flag == 1: counter += 1 orders_file = os.path.join("orders", file + ".csv") with open(orders_file, "w") as file: wr = csv.writer(file) wr.writerow(["Date", "Symbol", "Order", "Shares"]) wr.writerows(orders) start_val = 10000 portfolio, portfolio_SPY = compute_portvals(start_date, end_date, orders_file, start_val) df_temp = pd.concat([portfolio, portfolio_SPY], axis=1) bx = df_temp.plot(title="Daily Portfolio value " + titl) bx.set_xlabel("Date") bx.set_ylabel("Normalized Price") port_vals = portfolio[portfolio.columns[0]] cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = get_portfolio_stats(port_vals) # Simulate a $SPX-only reference portfolio to get stats portvals_SPY = get_portfolio_value(portfolio_SPY, [1.0]) cum_ret_SPY, avg_daily_ret_SPY, std_daily_ret_SPY, sharpe_ratio_SPY = get_portfolio_stats(portvals_SPY) # Compare portfolio against $SPX print "Data Range: {} to {}".format(start_date, end_date) print 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(port_vals[-1])
def test_orders_06(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-06.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 894604.3 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 210 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = -1.23463930987 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = -0.1053957 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.00657385746675 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = -0.000511281541086 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_09(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-09.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1067710.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 37 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 2.90848480553 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.06771 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0102202265027 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.00187252252117 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )
def test_orders_11(self): portvals = marketsim.compute_portvals(orders_file="./orders/orders-11.csv", start_val=1000000) final_portfolio_value = portvals.ix[-1, :][0] final_portfolio_dataframe_length = len(portvals) expected_value = 1078670.0 self.assertAlmostEqual( expected_value, final_portfolio_value, 4, "Final portfolio value is {} incorrect. Expected {}".format(final_portfolio_value, expected_value), delta=None, ) expected_value = 37 self.assertEqual( expected_value, final_portfolio_dataframe_length, "Final portfolio dataframe length {} is incorrect. Expected {}".format( final_portfolio_dataframe_length, expected_value ), ) success, cum_ret, avg_daily_ret, std_daily_ret, sharpe_ratio = self.try_get_portfolio_stats(portvals) if success: expected_value = 3.28377563093 self.assertAlmostEqual( expected_value, sharpe_ratio[0], 4, "Sharpe ratio {} is incorrect. Expected {}".format(sharpe_ratio[0], expected_value), delta=None, ) expected_value = 0.07867 self.assertAlmostEqual( expected_value, cum_ret[0], 4, "Cumulative return {} is incorrect. Expected {}".format(cum_ret[0], expected_value), delta=None, ) expected_value = 0.0104365693923 self.assertAlmostEqual( expected_value, std_daily_ret[0], 4, "Standard deviation {} is incorrect. Expected {}".format(std_daily_ret[0], expected_value), delta=None, ) expected_value = 0.00215889226484 self.assertAlmostEqual( expected_value, avg_daily_ret[0], 4, "Avg daily return {} is incorrect. Expected {}".format(avg_daily_ret[0], expected_value), delta=None, )