def rel_yearly_performance(self):
func_dict = {
'cum_return':
lambda x: stats.cum_returns_final(
self.portfolio_ret.reindex(x.index)),
'benchmark_return':
lambda x: stats.cum_returns_final(
self.benchmark_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':
partial(stats.information_ratio, factor_returns=0),
'monthly_win_rate':
partial(stats.win_rate, factor_returns=0, period='monthly'),
'weekly_win_rate':
partial(stats.win_rate, factor_returns=0, period='weekly'),
'daily_win_rate':
partial(stats.win_rate, factor_returns=0, period='daily')
}
df = resample_func(self.active_return, convert_to='1y', func=func_dict)
df.insert(2, 'active_return',
df['cum_return'] - df['benchmark_return'])
return df
def __test_returns(self):
p = Performance()
df = pd.DataFrame(index=pd.date_range('2010-01-01', periods=10),
columns=[
'returns',
])
df['returns'] = [
0.1, 0.1, 0.1, -0.156, -0.1, 0.1, 0.1, 0.1, -0.11, -0.1
]
#print(df)
r = df['returns']
ret = p.calc_period_return(r)
ret_annual = p.calc_annual_return(r)
print(stats.cum_returns_final(r))
#收益率
self.assertEqual(ret, stats.cum_returns_final(r))
self.assertEqual(ret_annual, stats.annual_return(r))
#print('标准差-年化波动率',)
#print(stats.annual_volatility(df['returns']))
#波动率，夏普比
self.assertEqual(p.calc_volatility(r), stats.annual_volatility(r))
self.assertEqual(p.calc_sharpe(r), stats.sharpe_ratio(r))
def rel_yearly_performance(self):
idx = GetDatetimeLastDayOfYear(self.active_return.index)
gfunc = lambda x: x.year
df = self.active_return.groupby(gfunc).agg({
'cum_return':
lambda x: stats.cum_returns_final(
self.portfolio_return.reindex(x.index)),
'benchmark_return':
lambda x: 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':
partial(stats.information_ratio, factor_returns=0),
'monthly_win_rate':
partial(stats.win_rate, factor_returns=0, period='monthly'),
'weekly_win_rate':
partial(stats.win_rate, factor_returns=0, period='weekly'),
'daily_win_rate':
partial(stats.win_rate, factor_returns=0, period='daily')
})
df.insert(2, 'active_return',
df['cum_return'] - df['benchmark_return'])
df.index = idx
return df
def range_pct(self, start, end, rel=True):
try:
if rel:
return stats.cum_returns_final(
self.active_return.loc[start:end])
else:
return stats.cum_returns_final(
self.portfolio_return.loc[start:end])
except:
return np.nan
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 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):
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 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 rel_total_return(self):
return stats.cum_returns_final(
self.active_return) - stats.cum_returns_final(
self.benchmark_return)
def abs_total_return(self):
return stats.cum_returns_final(self.portfolio_return)
def ls_total_return(self):
return stats.cum_returns_final(self.long_short_return)
def ls_range_pct(self, start, end):
try:
return stats.cum_returns_final(
self.long_short_return.loc[start:end])
except:
return np.nan
def total_benchmark_return(self):
return stats.cum_returns_final(self.benchmark_return)