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)