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