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,
)
