def make_return_tear_sheet_plot(self):
for item in self.df_list:
df = item[0]
daily_profit = df["daily_profit"]
tear_sheet_rt = pf.create_returns_tear_sheet(daily_profit,
return_fig=True)
figname = os.path.join(
self.output, self.plot_name + "_tear_sheet_return" + ".png")
tear_sheet_rt.savefig(figname, dpi=200)
# Drawdown
dd_plot = pf.plot_drawdown_periods(daily_profit, top=10)
full_tear_sheet_rt_ax = pf.create_full_tear_sheet(daily_profit)
# print(full_tear_sheet_rt_ax)
ddfigname = os.path.join(self.output,
self.plot_name + "_drawdown" + ".png")
dd_plot.figure.savefig(ddfigname)
def drawdown_periods(returns):
fig = plt.figure(facecolor='white')
plt.yscale('log')
ax = pf.plot_drawdown_periods(returns).set_xlabel('Date')
plt.savefig('drawdown_periods.png')
print(ann_ret_df)
if run_in_jupyter:
pf.create_full_tear_sheet(strat_ret,
benchmark_rets=bm_ret,
positions=df_positions,
transactions=df_trades,
round_trips=False)
plt.show()
else:
f1 = plt.figure(1)
pf.plot_rolling_returns(strat_ret, factor_returns=bm_ret)
f1.show()
f2 = plt.figure(2)
pf.plot_rolling_volatility(strat_ret, factor_returns=bm_ret)
f2.show()
f3 = plt.figure(3)
pf.plot_rolling_sharpe(strat_ret)
f3.show()
f4 = plt.figure(4)
pf.plot_drawdown_periods(strat_ret)
f4.show()
f5 = plt.figure(5)
pf.plot_monthly_returns_heatmap(strat_ret)
f5.show()
f6 = plt.figure(6)
pf.plot_annual_returns(strat_ret)
f6.show()
f7 = plt.figure(7)
pf.plot_monthly_returns_dist(strat_ret)
plt.show()
# In[21]:
result.tail()
# In[23]:
import pyfolio as pf
# In[24]:
returns, positions, transactions = pf.utils.extract_rets_pos_txn_from_zipline(
result)
# In[25]:
pf.plot_drawdown_periods(returns, top=5).set_xlabel('Date')
# In[26]:
transactions
# In[27]:
#pf.create_simple_tear_sheet(returns, positions=positions, transactions=transactions, live_start_date='2019-02-10')
#pf.create_full_tear_sheet(returns, positions=positions, transactions=transactions, live_start_date='2019-02-10', round_trips=True)
#pf.create_simple_tear_sheet(returns, positions=positions, transactions=transactions,live_start_date='2019-02-10')
sheets = pf.create_full_tear_sheet(returns,
positions=positions,
transactions=transactions)
# In[ ]:
def run_strategy(self,
cash=1000,
commission=0.0004,
tf=bt.TimeFrame.Minutes,
compression=60):
cerebro = bt.Cerebro()
cerebro.broker.setcommission(commission=commission)
cerebro.broker.setcash(cash)
data = FinamHLOC(dataname=self.file_data,
timeframe=tf,
compression=compression)
cerebro.addanalyzer(bt.analyzers.TimeReturn, _name='returns')
cerebro.adddata(data)
cerebro.addstrategy(
TrendBreakerPL,
pivot_window_len=self.algo_params['pivot_window_len'],
history_bars_as_multiple_pwl=self.
algo_params['history_bars_as_multiple_pwl'],
fixed_tp=self.algo_params['fixed_tp'],
fixed_sl_as_multiple_tp=self.
algo_params['fixed_sl_as_multiple_tp'],
order_full=self.output_settings['order_full'],
order_status=self.output_settings['order_status'],
trades=self.output_settings['trades'])
if self.output_settings['performance']:
print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
strats = cerebro.run()
first_strat = strats[0]
if self.output_settings['performance']:
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
od_returns = first_strat.analyzers.getbyname('returns').get_analysis()
df_returns = pd.DataFrame(od_returns.items(),
columns=['date', 'return'])
df_returns = df_returns.set_index('date')
self.stability = self.stability_of_timeseries(df_returns['return'])
if self.output_settings['performance']:
print('Performance:')
print('Return: ' +
str((cerebro.broker.getvalue() - cash) / cash * 100) + '%')
print('Stability:' + str(self.stability))
print('Top-5 Drawdowns:')
print(pf.show_worst_drawdown_periods(df_returns['return'], top=5))
if self.output_settings['plot']:
# Read Close prices from csv and calculate the returns as a benchmark
capital_algo = np.cumprod(1.0 + df_returns['return']) * cash
benchmark_df = pd.read_csv(self.file_data)
benchmark_returns = benchmark_df['<CLOSE>'].pct_change()
capital_benchmark = np.cumprod(1.0 + benchmark_returns) * cash
df_returns['benchmark_return'] = benchmark_returns
# Plot Capital Curves
plt.figure(figsize=(12, 7))
plt.plot(np.array(capital_algo), color='blue')
plt.plot(np.array(capital_benchmark), color='red')
plt.legend(['Algorithm', 'Buy & Hold'])
plt.title('Capital Curve')
plt.xlabel('Time')
plt.ylabel('Value')
plt.show()
# Plot Drawdown Underwater
plt.figure(figsize=(12, 7))
pf.plot_drawdown_underwater(
df_returns['return']).set_xlabel('Time')
plt.show()
# Plot Top-5 Drawdowns
plt.figure(figsize=(12, 7))
pf.plot_drawdown_periods(df_returns['return'],
top=5).set_xlabel('Time')
plt.show()
# Plot Simple Returns
plt.figure(figsize=(12, 7))
plt.plot(df_returns['return'], 'blue')
plt.title('Returns')
plt.xlabel('Time')
plt.ylabel('Return')
plt.show()
# Plot Return Quantiles by Timeframe
plt.figure(figsize=(12, 7))
pf.plot_return_quantiles(
df_returns['return']).set_xlabel('Timeframe')
plt.show()
# Plot Monthly Returns Dist
plt.figure(figsize=(12, 7))
pf.plot_monthly_returns_dist(
df_returns['return']).set_xlabel('Returns')
plt.show()
def plot_drawdown():
pf.plot_drawdown_periods(returns=returns, top=5)
plt.xlabel("Date")
plt.savefig("drawdown")
plt.show()
############################ pf.plot_return_quantiles(backtest_returns) ############################ # Rolling Plot # # frequency = M/Y # # BETA # ############################ pf.plot_rolling_beta(backtest_returns, benchmark_returns) ############################ # Rolling Plot # # frequency = M/Y # # SHARPE RATIO # ############################ pf.plot_rolling_sharpe(backtest_returns) ############################ # Top 10 Drawdown Periods # # frequency = M/Y # ############################ pf.plot_drawdown_periods(backtest_returns) ############################ # UnderWater Plot # # Drawdown Periods # # frequency = M/Y # # in values of = % # ############################ pf.plot_drawdown_underwater(backtest_returns)
plt.savefig(PATH + 'quantiles.png', dpi=300) plt.close() pf.plot_rolling_beta(bt_returns, benchmark_rets) plt.savefig(PATH + 'roll_beta.png', dpi=300) plt.close() pf.plot_rolling_sharpe(bt_returns) plt.savefig(PATH + 'roll_sharpe.png', dpi=300) plt.close() pf.plot_rolling_fama_french(bt_returns) plt.savefig(PATH + 'fama_french.png', dpi=300) plt.close() pf.plot_drawdown_periods(bt_returns) plt.savefig(PATH + 'drawdown.png', dpi=300) plt.close() pf.plot_drawdown_underwater(bt_returns) plt.savefig(PATH + 'underwater.png', dpi=300) plt.close() pf.plot_gross_leverage(bt_returns, bt_positions) plt.savefig(PATH + 'gross_lev.png', dpi=300) plt.close() pos_percent = pf.pos.get_percent_alloc(bt_positions) pf.plotting.show_and_plot_top_positions(bt_returns, pos_percent) plt.savefig(PATH + 'top_pos.png', dpi=300) plt.close()
def plot_performance(
returns,
benchmark_prices,
plot_stats=False,
startcash=None,
log_returns=False,
save_dir=None
):
"""
:param returns: pd.Series, return data
:param benchmark_prices: pd.Series, benchmark return data
:param startcash: int, rebase the benchmark if provided
:return: None
"""
if save_dir and not os.path.exists(save_dir):
os.makedirs(save_dir)
# Rebase benchmark prices, the same as portfolio prices
if startcash is not None:
benchmark_prices = (benchmark_prices / benchmark_prices.iloc[0]) * startcash
benchmark_rets = pyp.expected_returns.returns_from_prices(benchmark_prices)
if log_returns:
portfolio_value = returns.cumsum().apply(np.exp) * startcash
else:
portfolio_value = (1 + returns).cumprod() * startcash
# Performance statistics
if plot_stats:
pf.show_perf_stats(returns)
pf.show_perf_stats(benchmark_rets)
# Fig 1: price and return
fig, ax = plt.subplots(2, 1, sharex=True, figsize=[14, 8])
portfolio_value.plot(ax=ax[0], label='Portfolio')
benchmark_prices.plot(ax=ax[0], label='Benchmark')
ax[0].set_ylabel('Price')
ax[0].grid(True)
ax[0].legend()
returns.plot(ax=ax[1], label='Portfolio', alpha=0.5)
benchmark_rets.plot(ax=ax[1], label='Benchmark', alpha=0.5)
ax[1].set_ylabel('Return')
fig.suptitle('Black–Litterman Portfolio Optimization', fontsize=16)
plt.grid(True)
plt.legend()
plt.show()
if save_dir:
fig.savefig(os.path.join(save_dir, 'price_and_return'), dpi=300)
# Fig 2: return performance
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(16, 9), constrained_layout=False)
axes = ax.flatten()
pf.plot_rolling_beta(returns=returns, factor_returns=benchmark_rets, ax=axes[0])
pf.plot_return_quantiles(returns=returns, ax=axes[1])
pf.plot_annual_returns(returns=returns, ax=axes[2])
pf.plot_monthly_returns_heatmap(returns=returns, ax=axes[3])
axes[0].grid(True)
axes[1].grid(True)
axes[2].grid(True)
fig.suptitle('Return performance', fontsize=16, y=1.0)
plt.tight_layout()
if save_dir:
fig.savefig(os.path.join(save_dir, 'return_performance'), dpi=300)
# Fig 3: risk performance
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(14, 8), constrained_layout=False)
axes = ax.flatten()
pf.plot_drawdown_periods(returns=returns, ax=axes[0])
pf.plot_rolling_volatility(returns=returns, factor_returns=benchmark_rets, ax=axes[1])
pf.plot_drawdown_underwater(returns=returns, ax=axes[2])
pf.plot_rolling_sharpe(returns=returns, ax=axes[3])
axes[0].grid(True)
axes[1].grid(True)
axes[2].grid(True)
axes[3].grid(True)
fig.suptitle('Risk performance', fontsize=16, y=1.0)
plt.tight_layout()
if save_dir:
fig.savefig(os.path.join(save_dir, 'risk_performance'), dpi=300)
