def abs_yearly_performance(self):
idx = GetDatetimeLastDayOfYear(self.portfolio_return.index)
gfunc = lambda x: x.year
df = self.portfolio_return.groupby(gfunc).agg({
'cum_return':
(lambda x: stats.cum_returns_final(
self.portfolio_return.reindex(x.index)) - stats.
cum_returns_final(self.benchmark_return.reindex(x.index))),
'volatility':
lambda x: np.std(x, ddof=1) * 250**0.5,
'sharp_ratio':
lambda x: stats.sharpe_ratio(x, simple_interest=True),
'maxdd':
stats.max_drawdown,
'IR':
lambda x: stats.information_ratio(x, self.benchmark_return),
'monthly_win_rate':
lambda x: stats.win_rate(x, self.benchmark_return, 'monthly'),
'weekly_win_rate':
lambda x: stats.win_rate(x, self.benchmark_return, 'weekly'),
'daily_win_rate':
lambda x: stats.win_rate(x, self.benchmark_return, 'daily')
})
df.index = idx
return df
def rel_monthly_performance(self):
func_dict = {
'cum_return': (lambda x: stats.cum_returns_final(
self.portfolio_ret.reindex(x.index)) - stats.cum_returns_final(
self.benchmark_ret.reindex(x.index))),
'volatility':
lambda x: np.std(x, ddof=1) * 20**0.5,
'weekly_win_rate':
lambda x: stats.win_rate(x, 0, 'weekly'),
'daily_win_rate':
lambda x: stats.win_rate(x, 0, 'daily')
}
df = resample_func(self.active_return, convert_to='1m', func=func_dict)
return df
def rel_monthly_performance(self):
idx = GetDatetimeLastDayOfMonth(self.active_return.index)
gfunc = [lambda x: x.year, lambda x: x.month]
df = self.active_return.groupby(gfunc).agg({
'cum_return':
(lambda x: stats.cum_returns_final(
self.portfolio_return.reindex(x.index)) - stats.
cum_returns_final(self.benchmark_return.reindex(x.index))),
'volatility':
lambda x: np.std(x, ddof=1) * 20**0.5,
'weekly_win_rate':
lambda x: stats.win_rate(x, 0, 'weekly'),
'daily_win_rate':
lambda x: stats.win_rate(x, 0, 'daily')
})
df.index = idx
return df
def get_summary(self, freq='m'):
if freq == 'm':
monthlyRet = self.MonthlyRet(False)
monthlyBenchmarkRet = self.BenchmarkMonthlyRet()
hedgeMonthlyRet = self.MonthlyRet()
_dict = {
'annual_return':
stats.annual_return(hedgeMonthlyRet, annualization=12),
'annual_vol':
stats.annual_volatility(hedgeMonthlyRet, annualization=12),
'IR':
stats.information_ratio(monthlyRet, monthlyBenchmarkRet),
't_stats':
stats_scp.ttest_1samp(hedgeMonthlyRet, 0)[0],
'win_rate':
stats.win_rate(monthlyRet, monthlyBenchmarkRet),
'max_drawdown':
stats.max_drawdown(hedgeMonthlyRet),
'drawn_down_start':
pf.timeseries.get_top_drawdowns(hedgeMonthlyRet, 1)[0][0],
'draw_down_end':
pf.timeseries.get_top_drawdowns(hedgeMonthlyRet, 1)[0][1],
}
else:
_dict = {
'annual_return':
stats.annual_return(self.activeRet, annualization=12),
'annual_vol':
stats.annual_volatility(self.activeRet, annualization=12),
'IR':
stats.information_ratio(self.Ret, self.BenchmarkRet),
't_stats':
stats_scp.ttest_1samp(self.activeRet, 0)[0],
'win_rate':
stats.win_rate(self.Ret, self.BenchmarkRet),
'max_drawdown':
stats.max_drawdown(self.activeRet),
'drawn_down_start':
pf.timeseries.get_top_drawdowns(self.activeRet, 1)[0],
'draw_down_end':
pf.timeseries.get_top_drawdowns(self.activeRet, 1)[1],
}
return pd.Series(_dict)
def abs_yearly_performance(self):
func_dict = {
'cum_return':
lambda x: stats.cum_returns_final(
self.portfolio_ret.reindex(x.index)),
'volatility':
lambda x: np.std(x, ddof=1) * 250**0.5,
'sharp_ratio':
lambda x: stats.sharpe_ratio(x, simple_interest=True),
'maxdd':
stats.max_drawdown,
'IR':
lambda x: stats.information_ratio(x, self.benchmark_ret),
'monthly_win_rate':
lambda x: stats.win_rate(x, 0.0, 'monthly'),
'weekly_win_rate':
lambda x: stats.win_rate(x, 0.0, 'weekly'),
'daily_win_rate':
lambda x: stats.win_rate(x, 0.0, 'daily')
}
df = resample_func(self.portfolio_ret, convert_to='1y', func=func_dict)
return df
def YearlyPerformance(self):
monthlyRet = self.MonthlyRet(False) # 单边做多模型月度收益率
benchmarkMonthlyRet = self.BenchmarkMonthlyRet()
hedgeMonthlyRet = self.MonthlyRet(True) # 对冲组合月收益率
a = stats.aggregate_returns(monthlyRet, 'yearly') # 多头组合分年收益
b = stats.aggregate_returns(benchmarkMonthlyRet, 'yearly') # 基准组合分年收益
_l = []
for i, year in enumerate(a.index):
hedgeMonthlyRet_current_year = hedgeMonthlyRet.ix[str(year)]
monthlyRet_current_year = monthlyRet.ix[str(year)]
benchmarkMonthlyRet_current_year = benchmarkMonthlyRet.ix[str(
year)]
hdSharp_current_year = stats.sharpe_ratio(
hedgeMonthlyRet_current_year, annualization=12)
hdMaxDown_current_year = stats.max_drawdown(
hedgeMonthlyRet_current_year)
hdReturn_current_year = stats.annual_return(
hedgeMonthlyRet_current_year, annualization=12)
hdWinRate_current_year = stats.win_rate(
monthlyRet_current_year, benchmarkMonthlyRet_current_year)
_l.append([
hdSharp_current_year, hdReturn_current_year,
hdMaxDown_current_year, hdWinRate_current_year
])
# 计算全年收益表现
hdSharp_all = stats.sharpe_ratio(hedgeMonthlyRet, annualization=12)
hdMaxDown_all = stats.max_drawdown(hedgeMonthlyRet)
hdReturn_all = stats.annual_return(hedgeMonthlyRet, annualization=12)
hdWinRate_all = stats.win_rate(hedgeMonthlyRet, benchmarkMonthlyRet)
_l.append([hdSharp_all, hdReturn_all, hdMaxDown_all, hdWinRate_all])
result = pd.DataFrame(_l,
columns=['夏普比率', '年化收益', '最大回撤', '胜率'],
index=list(a.index) + ['All'])
return result
def total_performance(self):
"""策略全局表现"""
win_rate_func = lambda x, y: stats.win_rate(
x, factor_returns=0, period=y)
df = pd.DataFrame(
[[
self.abs_total_return, self.total_benchmark_return,
self.rel_total_return
],
[
self.abs_maxdrawdown,
stats.max_drawdown(self.benchmark_return),
self.rel_maxdrawdown
],
[
self.abs_annual_volatility,
stats.annual_volatility(self.benchmark_return),
self.rel_annual_volatility
],
[
self.abs_annual_return,
stats.annual_return(self.benchmark_return),
self.rel_annual_return
],
[
self.abs_sharp_ratio,
stats.sharpe_ratio(self.benchmark_return,
simple_interest=True), self.rel_sharp_ratio
],
[
win_rate_func(self.portfolio_return, 'monthly'),
win_rate_func(self.benchmark_return, 'monthly'),
win_rate_func(self.active_return, 'monthly')
]],
columns=['portfolio', 'benchmark', 'hedge'],
index=[
'total_return', 'maxdd', 'volatility', 'annual_return',
'sharp', 'win_rate'
])
return df
def WinRate(self, period='monthly'):
return stats.win_rate(self.Ret, self.BenchmarkRet, period=period)
