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