def augmentation(X, Y, noise = False, bootstrapping = True, noiseSTD = [0.1/2, 0.1/2, 0.01/2, 0.0002/2,0.01/2,0.02/2], nr_boot =1000, bootstrap_bl_size = 488, boot_freq = 100):
if noise:
Xn = X.copy()
for i, j, k in np.ndindex(X.shape):
Xn[i, j, k] += np.random.normal(0, 1)*noiseSTD[k]
X = np.vstack([X, Xn])
Y = np.vstack([Y, Y])
if bootstrapping:
Xb = X.copy()
pt = PowerTransformer(method='yeo-johnson', standardize=True)
for i in range(Xb.shape[0]):
pt.fit(Xb[i])
lambda_param = pt.lambdas_
transformed = pt.transform(Xb[i])
result = seasonal_decompose(transformed, model='additive', freq=boot_freq)
# Moving Block Bootstrap on Residuals
bootstrapRes = MBB(bootstrap_bl_size, result.resid)
for data in bootstrapRes.bootstrap(nr_boot):
bs_x = data[0][0]
reconSeriesYC = result.trend + result.seasonal + bs_x
Xb[i] = pt.inverse_transform(reconSeriesYC)
for i,j,k in np.ndindex(X.shape):
if np.isnan(Xb[i,j,k]):
Xb[i,j,k] = X[i,j,k]
X = np.vstack([X, Xb])
Y = np.vstack([Y, Y])
return X, Y
def test_uneven_sampling(bs_setup):
bs = MovingBlockBootstrap(block_size=31, y=bs_setup.y_series, x=bs_setup.x_df)
for _, kw in bs.bootstrap(10):
assert kw["y"].shape == bs_setup.y_series.shape
assert kw["x"].shape == bs_setup.x_df.shape
bs = CircularBlockBootstrap(block_size=31, y=bs_setup.y_series, x=bs_setup.x_df)
for _, kw in bs.bootstrap(10):
assert kw["y"].shape == bs_setup.y_series.shape
assert kw["x"].shape == bs_setup.x_df.shape
def test_uneven_sampling(self):
bs = MovingBlockBootstrap(block_size=31, y=self.y_series, x=self.x_df)
for _, kw in bs.bootstrap(10):
assert kw['y'].shape == self.y_series.shape
assert kw['x'].shape == self.x_df.shape
bs = CircularBlockBootstrap(block_size=31, y=self.y_series, x=self.x_df)
for _, kw in bs.bootstrap(10):
assert kw['y'].shape == self.y_series.shape
assert kw['x'].shape == self.x_df.shape
def test_uneven_sampling(self):
bs = MovingBlockBootstrap(block_size=31, y=self.y_series, x=self.x_df)
for _, kw in bs.bootstrap(10):
assert kw['y'].shape == self.y_series.shape
assert kw['x'].shape == self.x_df.shape
bs = CircularBlockBootstrap(block_size=31, y=self.y_series, x=self.x_df)
for _, kw in bs.bootstrap(10):
assert kw['y'].shape == self.y_series.shape
assert kw['x'].shape == self.x_df.shape
def moving_block_bootstrap_method(X, Y, block_size=50, n_samples=50):
boot_samples = []
bs = MovingBlockBootstrap(block_size, X, y=Y)
for samp in bs.bootstrap(n_samples):
boot_samples.append((samp[0][0], samp[1]['y']))
return boot_samples
def test_smoke(self):
num_bootstrap = 20
def func(y):
return y.mean(axis=0)
bs = StationaryBootstrap(13, self.y)
cov = bs.cov(func, reps=num_bootstrap)
bs = MovingBlockBootstrap(13, self.y)
cov = bs.cov(func, reps=num_bootstrap)
bs = CircularBlockBootstrap(13, self.y)
cov = bs.cov(func, reps=num_bootstrap)
bs = MovingBlockBootstrap(10, self.y)
cov = bs.cov(func, reps=num_bootstrap)
bs = CircularBlockBootstrap(10, self.y)
cov = bs.cov(func, reps=num_bootstrap)
def test_str(bs_setup):
bs = IIDBootstrap(bs_setup.y_series)
expected = "IID Bootstrap(no. pos. inputs: 1, no. keyword inputs: 0)"
assert_equal(str(bs), expected)
expected = expected[:-1] + ", ID: " + hex(id(bs)) + ")"
assert_equal(bs.__repr__(), expected)
expected = ("<strong>IID Bootstrap</strong>(" +
"<strong>no. pos. inputs</strong>: 1, " +
"<strong>no. keyword inputs</strong>: 0, " +
"<strong>ID</strong>: " + hex(id(bs)) + ")")
assert_equal(bs._repr_html(), expected)
bs = StationaryBootstrap(10, bs_setup.y_series, bs_setup.x_df)
expected = ("Stationary Bootstrap(block size: 10, no. pos. "
"inputs: 2, no. keyword inputs: 0)")
assert_equal(str(bs), expected)
expected = expected[:-1] + ", ID: " + hex(id(bs)) + ")"
assert_equal(bs.__repr__(), expected)
bs = CircularBlockBootstrap(block_size=20,
y=bs_setup.y_series,
x=bs_setup.x_df)
expected = ("Circular Block Bootstrap(block size: 20, no. pos. "
"inputs: 0, no. keyword inputs: 2)")
assert_equal(str(bs), expected)
expected = expected[:-1] + ", ID: " + hex(id(bs)) + ")"
assert_equal(bs.__repr__(), expected)
expected = ("<strong>Circular Block Bootstrap</strong>" +
"(<strong>block size</strong>: 20, " +
"<strong>no. pos. inputs</strong>: 0, " +
"<strong>no. keyword inputs</strong>: 2," +
" <strong>ID</strong>: " + hex(id(bs)) + ")")
assert_equal(bs._repr_html(), expected)
bs = MovingBlockBootstrap(block_size=20,
y=bs_setup.y_series,
x=bs_setup.x_df)
expected = ("Moving Block Bootstrap(block size: 20, no. pos. "
"inputs: 0, no. keyword inputs: 2)")
assert_equal(str(bs), expected)
expected = expected[:-1] + ", ID: " + hex(id(bs)) + ")"
assert_equal(bs.__repr__(), expected)
expected = ("<strong>Moving Block Bootstrap</strong>" +
"(<strong>block size</strong>: 20, " +
"<strong>no. pos. inputs</strong>: 0, " +
"<strong>no. keyword inputs</strong>: 2," +
" <strong>ID</strong>: " + hex(id(bs)) + ")")
assert_equal(bs._repr_html(), expected)
def test_str(self):
bs = IIDBootstrap(self.y_series)
expected = 'IID Bootstrap(no. pos. inputs: 1, no. keyword inputs: 0)'
assert_equal(str(bs), expected)
expected = expected[:-1] + ', ID: ' + hex(id(bs)) + ')'
assert_equal(bs.__repr__(), expected)
expected = '<strong>IID Bootstrap</strong>(' + \
'<strong>no. pos. inputs</strong>: 1, ' + \
'<strong>no. keyword inputs</strong>: 0, ' + \
'<strong>ID</strong>: ' + hex(id(bs)) + ')'
assert_equal(bs._repr_html(), expected)
bs = StationaryBootstrap(10, self.y_series, self.x_df)
expected = 'Stationary Bootstrap(block size: 10, no. pos. ' \
'inputs: 2, no. keyword inputs: 0)'
assert_equal(str(bs), expected)
expected = expected[:-1] + ', ID: ' + hex(id(bs)) + ')'
assert_equal(bs.__repr__(), expected)
bs = CircularBlockBootstrap(block_size=20,
y=self.y_series,
x=self.x_df)
expected = 'Circular Block Bootstrap(block size: 20, no. pos. ' \
'inputs: 0, no. keyword inputs: 2)'
assert_equal(str(bs), expected)
expected = expected[:-1] + ', ID: ' + hex(id(bs)) + ')'
assert_equal(bs.__repr__(), expected)
expected = '<strong>Circular Block Bootstrap</strong>' + \
'(<strong>block size</strong>: 20, ' \
+ '<strong>no. pos. inputs</strong>: 0, ' + \
'<strong>no. keyword inputs</strong>: 2,' + \
' <strong>ID</strong>: ' + hex(id(bs)) + ')'
assert_equal(bs._repr_html(), expected)
bs = MovingBlockBootstrap(block_size=20, y=self.y_series, x=self.x_df)
expected = 'Moving Block Bootstrap(block size: 20, no. pos. ' \
'inputs: 0, no. keyword inputs: 2)'
assert_equal(str(bs), expected)
expected = expected[:-1] + ', ID: ' + hex(id(bs)) + ')'
assert_equal(bs.__repr__(), expected)
expected = '<strong>Moving Block Bootstrap</strong>' + \
'(<strong>block size</strong>: 20, ' \
+ '<strong>no. pos. inputs</strong>: 0, ' + \
'<strong>no. keyword inputs</strong>: 2,' + \
' <strong>ID</strong>: ' + hex(id(bs)) + ')'
assert_equal(bs._repr_html(), expected)
def mbb_bootstrap(self):
"""
return paths simulated using the moving block bootstrap
params:
-------
- self: see above
return:
-------
- none
"""
print("\nMB BOOTSTRAP \n")
bs = MovingBlockBootstrap(self.blocksize, self.data)
out_mbb = boot(N_paths=self.n_paths,
method=bs,
obs_path=self.data,
add_noise=self.add_noise)
if self.store_sim:
self.simulated_paths['MBB'] = out_mbb.iloc[:, :out_mbb.
shape[1] if out_mbb.
shape[1] < 100 else 100]
self.store_output = investment_horizons(
observed_path=self.data,
sims=out_mbb,
investment_horizons=self.ih,
freq=self.frequency,
sum_stats=self.stats,
perf_functions=self.perf_functions,
store_output_dic=self.store_output,
simulation_tech='MBB',
plotting=self.plotting)
return None
def metrics():
import hypothesisTest.bets as bets
import hypothesisTest.data as data
import numpy as np
import hypothesisTest.plots as plots
import hypothesisTest.helper_functions as hf
import pandas as pd
import math as mth
from scipy import stats
datasets = data.datasets_dict
benchmark_returns = datasets['benchmark'][bets.clean_values_from_weights]
rf_returns = datasets['rf_rate'][bets.clean_values_from_weights]
fama_factors = datasets['Fama_French'][bets.clean_values_from_weights]
cleaned_index = bets.cleaned_index_weights
res_dict = dict()
##############################################################################################
res_dict['cleaned_index'] = cleaned_index
#A. General Characterstics
#1. Time range
res_dict['START_DATE'] = cleaned_index.min()
res_dict['END_DATE'] = cleaned_index.max()
res_dict['TIME_RANGE_DAYS'] = (
(cleaned_index.max() -
cleaned_index.min()).astype('timedelta64[D]')) / np.timedelta64(
1, 'D')
#years = ((end_date-start_date).astype('timedelta64[Y]'))/np.timedelta64(1, 'Y')
res_dict['TOTAL_BARS'] = len(cleaned_index)
#2. Average AUM
res_dict['AVERAGE_AUM'] = np.nanmean(
np.nansum(np.abs(bets.dollars_at_open), axis=1))
#3. Capacity of Strategy
#4. Leverage (!!! Double check -something to do with sum of long_lev and short_lev > 1)
res_dict['AVERAGE_POSITION_SIZE'] = np.nanmean(
np.nansum(bets.dollars_at_open, axis=1))
res_dict['NET_LEVERAGE'] = round(
res_dict['AVERAGE_POSITION_SIZE'] / res_dict['AVERAGE_AUM'], 2)
#5. Turnover
daily_shares = np.nansum(bets.purchased_shares, axis=1)
daily_value_traded = np.nansum(np.abs(bets.dollars_at_open), axis=1)
daily_turnover = daily_shares / (2 * daily_value_traded)
res_dict['AVERAGE_DAILY_TURNOVER'] = np.mean(daily_turnover)
#6. Correlation to underlying
res_dict['CORRELATION_WITH_UNDERLYING'] = np.corrcoef(
bets.underlying_daily_returns, bets.strategy_daily_returns)[0, 1]
#7. Ratio of longs
res_dict['LONG_RATIO'] = ((bets.cleaned_strategy_weights > 0).sum()) / (
np.ones(bets.cleaned_strategy_weights.shape, dtype=bool).sum())
#8. Maximum dollar position size
res_dict['MAX_SIZE'] = np.nanmax(np.abs(bets.cleaned_strategy_weights))
#9. Stability of Wealth Process
cum_log_returns = np.log1p(bets.strategy_daily_returns).cumsum()
rhat = stats.linregress(np.arange(len(cum_log_returns)),
cum_log_returns)[2]
res_dict['STABILITY_OF_WEALTH_PROCESS'] = rhat**2
##############################################################################################
# B. Performance measures
#1. Equity curves
def equity_curve(amount, ret):
ret = hf.shift_array(ret, 1, 0)
return amount * np.cumprod(1 + ret)
curves = dict()
curves['Strategy'] = equity_curve(bets.starting_value,
bets.strategy_daily_returns)
curves['Buy & Hold Underlying'] = equity_curve(
bets.starting_value, bets.underlying_daily_returns)
curves['Benchmark'] = equity_curve(bets.starting_value, benchmark_returns)
curves['Risk free Asset'] = equity_curve(bets.starting_value, rf_returns)
curves['Long Contribution'] = equity_curve(bets.starting_value,
bets.long_contribution)
curves['Short Contribution'] = equity_curve(bets.starting_value,
bets.short_contribution)
plot_data_DF1 = pd.DataFrame([])
plot_data_DF1['time'] = cleaned_index
plot_data_DF1['time'] = plot_data_DF1['time'].astype(np.int64) / int(1e6)
plot_data_DF1['yValue'] = curves['Strategy']
# plot_data_DF2 = pd.DataFrame([])
# plot_data_DF2['time']=plot_data_DF1['time']
# plot_data_DF2['yValue'] = curves['Benchmark']
plotData1 = [[plot_data_DF1['time'][n], curves['Strategy'][n]]
for n in range(len(cleaned_index))]
plotData2 = [[plot_data_DF1['time'][n], curves['Benchmark'][n]]
for n in range(len(cleaned_index))]
# for n in range(len(cleaned_index)):
# plotData1.append([plot_data_DF1['time'][n], curves['Strategy'][n]])
# plotData2.append([plot_data_DF1['time'][n], curves['Benchmark'][n]])
# plots.equity_curves_plot(cleaned_index, curves)
res_dict['curves'] = curves
#2. Pnl from long positions check long_pnl
res_dict['PNL_FROM_STRATEGY'] = curves['Strategy'][-1]
res_dict['PNL_FROM_LONG'] = curves['Long Contribution'][-1]
#3. Annualized rate of return (Check this)
res_dict['ANNUALIZED_AVERAGE_RATE_OF_RETURN'] = round(
((1 + np.mean(bets.strategy_daily_returns))**(365) - 1) * 100, 2)
res_dict['CUMMULATIVE_RETURN'] = (
np.cumprod(1 + bets.strategy_daily_returns)[-1] - 1)
yrs = res_dict['TOTAL_BARS'] / 252
res_dict['CAGR_STRATEGY'] = (
(curves['Strategy'][-1] / curves['Strategy'][0])**(1 / yrs)) - 1
res_dict['CAGR_BENCHMARK'] = (
(curves['Benchmark'][-1] / curves['Benchmark'][0])**(1 / yrs)) - 1
#4. Hit Ratio
res_dict['HIT_RATIO'] = round(
((bets.daily_pnl > 0).sum()) / ((bets.daily_pnl > 0).sum() +
(bets.daily_pnl < 0).sum() +
(bets.daily_pnl == 0).sum()) * 100, 2)
##############################################################################################
# C. Runs
# 1. Runs concentration
def runs(returns):
wght = returns / returns.sum()
hhi = (wght**2).sum()
hhi = (hhi - returns.shape[0]**-1) / (1. - returns.shape[0]**-1)
return hhi
res_dict['HHI_PLUS'] = runs(
bets.strategy_daily_returns[bets.strategy_daily_returns > 0])
res_dict['HHI_MINUS'] = runs(
bets.strategy_daily_returns[bets.strategy_daily_returns < 0])
# 2. Drawdown and Time under Water
def MDD(returns):
def returns_to_dollars(amount, ret):
return amount * np.cumprod(1 + ret)
doll_series = pd.Series(returns_to_dollars(100, returns))
Roll_Max = doll_series.cummax()
Daily_Drawdown = doll_series / Roll_Max - 1.0
Max_Daily_Drawdown = Daily_Drawdown.cummin()
return Max_Daily_Drawdown
DD_strategy = MDD(bets.strategy_daily_returns)
DD_benchmark = MDD(benchmark_returns)
res_dict['MDD_STRATEGY'] = DD_strategy.min()
res_dict['MDD_BENCHMARK'] = DD_benchmark.min()
#3. 95 percentile
res_dict['95PERCENTILE_DRAWDOWN_STRATEGY'] = DD_strategy.quantile(0.05)
res_dict['95PERCENTILE_DRAWDOWN_BENCHMARK'] = DD_benchmark.quantile(0.05)
#############################################################################################
# D. Efficiency
#1. Sharpe Ratio
excess_returns = bets.strategy_daily_returns - rf_returns
res_dict['SHARPE_RATIO'] = round(
mth.sqrt(252) * np.mean(excess_returns) / np.std(excess_returns), 2)
#from statsmodels.graphics.tsaplots import plot_acf
#plot_acf(excess_returns)
#2. sortino Ratio
res_dict['SORTINO_RATIO'] = mth.sqrt(252) * np.mean(
excess_returns) / np.std(
excess_returns[excess_returns < np.mean(excess_returns)])
#2.Probabilistic Sharpe ratio
from scipy.stats import norm
from scipy.stats import kurtosis, skew
g_3 = skew(excess_returns)
g_4 = kurtosis(excess_returns)
res_dict['PROBABILISTIC_SHARPE_RATIO'] = norm.cdf(
((res_dict['SHARPE_RATIO'] - 2) * mth.sqrt(len(excess_returns) - 1)) /
(mth.sqrt(1 - (g_3 * res_dict['SHARPE_RATIO']) +
(0.25 * (g_4 - 1) * res_dict['SHARPE_RATIO'] *
res_dict['SHARPE_RATIO']))))
#3.Information ratio
excess_returns_benchmark = bets.strategy_daily_returns - benchmark_returns
res_dict['INFORMATION_RATIO'] = mth.sqrt(252) * np.mean(
excess_returns_benchmark) / np.std(excess_returns_benchmark)
#3. t_stat & P-value
m = np.mean(excess_returns)
s = np.std(excess_returns)
n = len(excess_returns)
t_stat = (m / s) * mth.sqrt(n)
res_dict['t_STATISTIC'] = t_stat
pval = stats.t.sf(np.abs(t_stat), n**2 -
1) * 2 # Must be two-sided as we're looking at <> 0
res_dict['p-VALUE'] = round(pval * 100, 2)
if pval <= 0.0001:
res_dict['SIGNIFICANCE_AT_0.01%'] = 'STATISTICALLY_SIGNIFICANT'
else:
res_dict['SIGNIFICANCE_AT_0.01%'] = 'NOT_STATISTICALLY_SIGNIFICANT'
#4. Omega Ratio
returns_less_thresh = excess_returns - (((100)**(1 / 252)) - 1)
numer = sum(returns_less_thresh[returns_less_thresh > 0.0])
denom = -1.0 * sum(returns_less_thresh[returns_less_thresh < 0.0])
res_dict['OMEGA_RATIO'] = numer / denom
#5. Tail Ratio
res_dict['TAIL_RATIO'] = np.abs(
np.percentile(bets.strategy_daily_returns, 95)) / np.abs(
np.percentile(bets.strategy_daily_returns, 5))
#6. Rachev Ratio
left_threshold = np.percentile(excess_returns, 5)
right_threshold = np.percentile(excess_returns, 95)
CVAR_left = -1 * (np.nanmean(
excess_returns[excess_returns <= left_threshold]))
CVAR_right = (np.nanmean(
excess_returns[excess_returns >= right_threshold]))
res_dict['RACHEV_RATIO'] = CVAR_right / CVAR_left
#############################################################################################
# E. RISK MEASURES
#1. SKEWNESS, KURTOSIS
res_dict['SKEWNESS'] = stats.skew(bets.strategy_daily_returns, bias=False)
res_dict['KURTOSIS'] = stats.kurtosis(bets.strategy_daily_returns,
bias=False)
#2. ANNUALIZED VOLATILITY
res_dict['ANNUALIZED_VOLATILITY'] = np.std(
bets.strategy_daily_returns) * np.sqrt(252)
#3. MAR Ratio
res_dict['MAR_RATIO'] = (res_dict['CAGR_STRATEGY']) / abs(
res_dict['MDD_STRATEGY'])
#############################################################################################
# F. Classification scores
sign_positions = np.sign(bets.purchased_shares).flatten()
sign_profits = np.sign(bets.pnl).flatten()
invalid = np.argwhere(np.isnan(sign_positions + sign_profits))
sign_positions_final = np.delete(sign_positions, invalid)
sign_profits_final = np.delete(sign_profits, invalid)
from sklearn.metrics import precision_recall_fscore_support as score
precision, recall, fscore, support = score(sign_profits_final,
sign_positions_final)
precision = np.float16(np.int16(precision * 100000)) / 100000.0
recall = np.float16(np.int16(recall * 100000)) / 100000.0
fscore = np.float16(np.int16(fscore * 100000)) / 100000.0
support = np.float16(np.int16(support * 100000)) / 100000.0
res_dict['CLASSIFICATION_DATA'] = {
'Class': ['-1', '0', '1'],
'Precision': list(precision),
'Recall': list(recall),
'F-Score': list(fscore),
'Support': list(support)
}
# res_dict['CLASSIFICATION_DATA']= #pd.DataFrame(res_dict['CLASSIFICATION_DATA'])
#############################################################################################
# G. Factor Analysis
import statsmodels.formula.api as sm # module for stats models
from statsmodels.iolib.summary2 import summary_col
def assetPriceReg(excess_ret, fama):
df_stock_factor = pd.DataFrame({
'ExsRet': excess_ret,
'MKT': fama[:, 0],
'SMB': fama[:, 1],
'HML': fama[:, 2],
'RMW': fama[:, 3],
'CMA': fama[:, 4]
})
CAPM = sm.ols(formula='ExsRet ~ MKT',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
FF3 = sm.ols(formula='ExsRet ~ MKT + SMB + HML',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
FF5 = sm.ols(formula='ExsRet ~ MKT + SMB + HML + RMW + CMA',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
CAPMtstat = CAPM.tvalues
FF3tstat = FF3.tvalues
FF5tstat = FF5.tvalues
CAPMcoeff = CAPM.params
FF3coeff = FF3.params
FF5coeff = FF5.params
# DataFrame with coefficients and t-stats
results_df = pd.DataFrame(
{
'CAPMcoeff': CAPMcoeff,
'CAPMtstat': CAPMtstat,
'FF3coeff': FF3coeff,
'FF3tstat': FF3tstat,
'FF5coeff': FF5coeff,
'FF5tstat': FF5tstat
},
index=['Intercept', 'MKT', 'SMB', 'HML', 'RMW', 'CMA'])
dfoutput = summary_col(
[CAPM, FF3, FF5],
stars=True,
float_format='%0.4f',
model_names=[
'CAPM', 'Fama-French 3 Factors', 'Fama-French 5 factors'
],
info_dict={
'N': lambda x: "{0:d}".format(int(x.nobs)),
'Adjusted R2': lambda x: "{:.4f}".format(x.rsquared_adj)
},
regressor_order=['Intercept', 'MKT', 'SMB', 'HML', 'RMW', 'CMA'])
print(dfoutput)
return dfoutput, results_df
res_dict['FACTOR_RES'], _ = assetPriceReg(excess_returns, fama_factors)
#############################################################################################
# H. Bootstrap Stats
# 1. Sharpe Bootstrap
from arch.bootstrap import MovingBlockBootstrap
from numpy.random import RandomState
bs_sharpe = MovingBlockBootstrap(5,
excess_returns,
random_state=RandomState(1234))
def sharpe(y):
return (mth.sqrt(252) * np.mean(y)) / np.std(y)
res = bs_sharpe.apply(sharpe, 10000)
# plots.density_plot_bootstrap(res,res_dict['SHARPE_RATIO'])
############################################################################################
return res_dict, [plotData1, plotData2]
def get_MBB_reminders(num_samples, remainder):
reminders = np.zeros((num_samples, remainder.size))
bs = MBB(3, remainder)
for i, data in enumerate(bs.bootstrap(num_samples)):
reminders[i] = data[0][0]
return reminders
def metrics(datasets_dict, clean_values_from_weights, cleaned_index_weights,
daily_pnl, pnl, strategy_log_returns, dollars_at_open,
purchased_shares, underlying_daily_returns,
cleaned_strategy_weights, starting_value, long_contribution,
short_contribution, strategy_daily_returns):
import numpy as np
import hypothesisTest.utilities as hf
import pandas as pd
import math as mth
from scipy import stats
from scipy.stats import norm
from scipy.stats import kurtosis, skew
datasets = datasets_dict
benchmark_returns = datasets['benchmark'][clean_values_from_weights]
rf_returns = datasets['rf_rate'][clean_values_from_weights]
fama_factors = datasets['Fama_French'][clean_values_from_weights]
cleaned_index = cleaned_index_weights
excess_returns = strategy_log_returns - rf_returns
res_dict = dict()
##############################################################################################
#A. General Characterstics
#1. Time
res_dict['START_DATE'] = hf.to_datetime(
cleaned_index.min()).strftime("%d %B, %Y")
res_dict['END_DATE'] = hf.to_datetime(
cleaned_index.max()).strftime("%d %B, %Y")
res_dict['TIME_RANGE_DAYS'] = '{0:.0f} days'.format(
int(((cleaned_index.max() -
cleaned_index.min()).astype('timedelta64[D]')) /
np.timedelta64(1, 'D')))
res_dict['TOTAL_BARS'] = '{0:.0f} bars'.format(int(len(cleaned_index)))
sr = mth.sqrt(252) * np.mean(excess_returns) / np.std(excess_returns)
def minTRL(sharpe, skew, kurtosis, target_sharpe=0, prob=0.95):
from scipy.stats import norm
min_track = (1 + (1 - skew * sharpe + sharpe**2 *
(kurtosis - 1) / 4.0) *
(norm.ppf(prob) / (sharpe - target_sharpe))**2)
return min_track
g_3 = skew(excess_returns)
g_4 = kurtosis(excess_returns)
res_dict['MIN_TRL_SRGE1_99%'] = '{0:.0f} bars or {1:.2f} years'.format(
minTRL(sr, g_3, g_4, 1, 0.99),
minTRL(sr, g_3, g_4, 1, 0.99) / 252)
res_dict['MIN_TRL_SRGE2_99%'] = '{0:.0f} bars or {1:.2f} years'.format(
minTRL(sr, g_3, g_4, 2, 0.99),
minTRL(sr, g_3, g_4, 2, 0.99) / 252)
res_dict['MIN_TRL_SRGE3_99%'] = '{0:.0f} bars or {1:.2f} years'.format(
minTRL(sr, g_3, g_4, 3, 0.99),
minTRL(sr, g_3, g_4, 3, 0.99) / 252)
#2. Average AUM
avg_aum = np.nanmean(np.nansum(np.abs(dollars_at_open), axis=1))
res_dict['AVERAGE_AUM'] = hf.millions_fmt(avg_aum)
#3. Capacity of Strategy
# res_dict['STRATEGY_CAPACITY'] = hf.millions_fmt(0)
#4. Leverage (!!! Double check -something to do with sum of long_lev and short_lev > 1)
avg_pos_size = np.nanmean(np.nansum(dollars_at_open, axis=1))
res_dict['AVERAGE_POSITION_SIZE'] = hf.millions_fmt(avg_pos_size)
res_dict['NET_LEVERAGE'] = '{0:.1f}'.format(avg_pos_size / avg_aum)
#5. Turnover
daily_shares = np.nansum(purchased_shares, axis=1)
daily_value_traded = np.nansum(np.abs(dollars_at_open), axis=1)
daily_turnover = daily_shares / (2 * daily_value_traded)
res_dict['AVERAGE_DAILY_TURNOVER'] = hf.millions_fmt(
np.mean(daily_turnover))
#6. Correlation to underlying
res_dict['CORRELATION_WITH_UNDERLYING'] = '{0:.2f}'.format(
np.corrcoef(underlying_daily_returns, strategy_log_returns)[0, 1])
#7. Ratio of longs
res_dict['LONG_RATIO'] = '{0:.2f} %'.format(
(((cleaned_strategy_weights > 0).sum()) /
(np.ones(cleaned_strategy_weights.shape, dtype=bool).sum())) * 100)
#8. Maximum dollar position size
res_dict['MAX_SIZE'] = '{0:.2f} %'.format(
np.nanmax(np.abs(cleaned_strategy_weights)) * 100)
#9. Stability of Wealth Process
cum_log_returns = np.log1p(strategy_log_returns).cumsum()
rhat = stats.linregress(np.arange(len(cum_log_returns)),
cum_log_returns)[2]
res_dict['STABILITY_OF_WEALTH_PROCESS'] = '{0:.2f} %'.format(
(rhat**2) * 100)
##############################################################################################
# B. Performance measures
#1. Equity curves
def equity_curve(amount, ret):
ret = hf.shift_array(ret, 1, 0)
return amount * np.cumprod(1 + ret)
curves = dict()
curves['Strategy'] = equity_curve(starting_value, strategy_daily_returns)
curves['Buy & Hold Underlying'] = equity_curve(starting_value,
underlying_daily_returns)
curves['Benchmark'] = equity_curve(starting_value, benchmark_returns)
curves['Risk free Asset'] = equity_curve(starting_value, rf_returns)
curves['Long Contribution'] = equity_curve(starting_value,
long_contribution)
curves['Short Contribution'] = equity_curve(starting_value,
short_contribution)
curves['time_index'] = cleaned_index
df = pd.DataFrame.from_dict(curves)
df = df.set_index('time_index')
res_dict['PLOT_CURVES_DATA'] = df
#2. Pnl from long positions check long_pnl
res_dict['PNL_FROM_STRATEGY'] = hf.millions_fmt(curves['Strategy'][-1])
res_dict['PNL_FROM_LONG'] = hf.millions_fmt(
curves['Long Contribution'][-1])
#3. Annualized rate of return (Check this)
res_dict['ANNUALIZED_MEAN_RETURN'] = '{0:.2f} %'.format(
(((1 + np.mean(strategy_daily_returns))**(365) - 1)) * 100)
res_dict['CUMMULATIVE_RETURN'] = '{0:.2f} %'.format(
(np.cumprod(1 + strategy_daily_returns)[-1] - 1) * 100)
yrs = int(len(cleaned_index)) / 252
cagr_strategy = ((
(curves['Strategy'][-1] / curves['Strategy'][0])**(1 / yrs)) - 1)
res_dict['CAGR_STRATEGY'] = '{0:.2f} %'.format(
(((curves['Strategy'][-1] / curves['Strategy'][0])**(1 / yrs)) - 1) *
100)
res_dict['CAGR_BENCHMARK'] = '{0:.2f} %'.format(
(((curves['Benchmark'][-1] / curves['Benchmark'][0])**(1 / yrs)) - 1) *
100)
#4. Hit Ratio
res_dict['HIT_RATIO'] = '{0:.2f} %'.format(
(((daily_pnl > 0).sum()) /
((daily_pnl > 0).sum() + (daily_pnl < 0).sum() +
(daily_pnl == 0).sum())) * 100)
##############################################################################################
# C. Runs
# 1. Runs concentration
def runs(returns):
wght = returns / returns.sum()
hhi = (wght**2).sum()
hhi = (hhi - returns.shape[0]**-1) / (1. - returns.shape[0]**-1)
return hhi
res_dict['HHI_PLUS'] = '{0:.5f}'.format(
runs(strategy_log_returns[strategy_log_returns > 0]))
res_dict['HHI_MINUS'] = '{0:.5f}'.format(
runs(strategy_log_returns[strategy_log_returns < 0]))
# 2. Drawdown and Time under Water
def MDD(returns):
def returns_to_dollars(amount, ret):
return amount * np.cumprod(1 + ret)
doll_series = pd.Series(returns_to_dollars(100, returns))
Roll_Max = doll_series.cummax()
Daily_Drawdown = doll_series / Roll_Max - 1.0
Max_Daily_Drawdown = Daily_Drawdown.cummin()
return Max_Daily_Drawdown
DD_strategy = MDD(strategy_log_returns)
DD_benchmark = MDD(benchmark_returns)
mdd_strat = DD_strategy.min()
res_dict['MDD_STRATEGY'] = '{0:.2f} %'.format(DD_strategy.min() * 100)
res_dict['MDD_BENCHMARK'] = '{0:.2f} %'.format(DD_benchmark.min() * 100)
#3. 95 percentile
# res_dict['95PERCENTILE_DRAWDOWN_STRATEGY']=DD_strategy.quantile(0.05)
# res_dict['95PERCENTILE_DRAWDOWN_BENCHMARK']=DD_benchmark.quantile(0.05)
#############################################################################################
# D. Efficiency
#1. Sharpe Ratio
excess_returns = strategy_log_returns - rf_returns
res_dict['SHARPE_RATIO'] = '{0:.2f}'.format(
mth.sqrt(252) * np.mean(excess_returns) / np.std(excess_returns))
res_dict['PROBABILISTIC_SR_GE_1'] = '{0:.2f} %'.format((norm.cdf(
((sr - 1) * mth.sqrt((len(excess_returns) - 1) / 252)) /
(mth.sqrt(1 - (g_3 * sr) + (0.25 * (g_4 - 1) * sr * sr))))) * 100)
res_dict['PROBABILISTIC_SR_GE_2'] = '{0:.2f} %'.format((norm.cdf(
((sr - 2) * mth.sqrt((len(excess_returns) - 1) / 252)) /
(mth.sqrt(1 - (g_3 * sr) + (0.25 * (g_4 - 1) * sr * sr))))) * 100)
res_dict['PROBABILISTIC_SR_GE_3'] = '{0:.2f} %'.format((norm.cdf(
((sr - 3) * mth.sqrt((len(excess_returns) - 1) / 252)) /
(mth.sqrt(1 - (g_3 * sr) + (0.25 * (g_4 - 1) * sr * sr))))) * 100)
#2. sortino Ratio
res_dict['SORTINO_RATIO'] = '{0:.2f}'.format(
mth.sqrt(252) * np.mean(excess_returns) /
np.std(excess_returns[excess_returns < np.mean(excess_returns)]))
#2.Probabilistic Sharpe ratio
#3.Information ratio
excess_returns_benchmark = strategy_log_returns - benchmark_returns
res_dict['INFORMATION_RATIO'] = '{0:.2f}'.format(
mth.sqrt(252) * np.mean(excess_returns_benchmark) /
np.std(excess_returns_benchmark))
#3. t_stat & P-value
m = np.mean(excess_returns)
s = np.std(excess_returns)
n = len(excess_returns)
t_stat = (m / s) * mth.sqrt(n)
res_dict['t_STATISTIC'] = '{0:.2f}'.format(t_stat)
pval = stats.t.sf(np.abs(t_stat), n**2 -
1) * 2 # Must be two-sided as we're looking at <> 0
res_dict['p-VALUE'] = '{0:.5f} %'.format(pval * 100)
if pval <= 0.0001:
res_dict['SIGNIFICANCE_AT_0.01%'] = 'STATISTICALLY_SIGNIFICANT'
else:
res_dict['SIGNIFICANCE_AT_0.01%'] = 'NOT_STATISTICALLY_SIGNIFICANT'
#4. Omega Ratio
returns_less_thresh = excess_returns - (((100)**(1 / 252)) - 1)
numer = sum(returns_less_thresh[returns_less_thresh > 0.0])
denom = -1.0 * sum(returns_less_thresh[returns_less_thresh < 0.0])
res_dict['OMEGA_RATIO'] = '{0:.2f}'.format(numer / denom)
#5. Tail Ratio
res_dict['TAIL_RATIO'] = '{0:.2f}'.format(
np.abs(np.percentile(strategy_log_returns, 95)) /
np.abs(np.percentile(strategy_log_returns, 5)))
#6. Rachev Ratio
left_threshold = np.percentile(excess_returns, 5)
right_threshold = np.percentile(excess_returns, 95)
CVAR_left = -1 * (np.nanmean(
excess_returns[excess_returns <= left_threshold]))
CVAR_right = (np.nanmean(
excess_returns[excess_returns >= right_threshold]))
res_dict['RACHEV_RATIO'] = '{0:.2f}'.format(CVAR_right / CVAR_left)
#############################################################################################
# E. RISK MEASURES
#1. SKEWNESS, KURTOSIS
res_dict['SKEWNESS'] = '{0:.2f}'.format(
stats.skew(strategy_log_returns, bias=False))
res_dict['KURTOSIS'] = '{0:.2f}'.format(
stats.kurtosis(strategy_log_returns, bias=False))
#2. ANNUALIZED VOLATILITY
res_dict['ANNUALIZED_VOLATILITY'] = '{0:.2f} %'.format(
np.std(strategy_log_returns) * np.sqrt(252) * 100)
#3. MAR Ratio
res_dict['MAR_RATIO'] = '{0:.2f}'.format((cagr_strategy) / abs(mdd_strat))
#4 Tracking Error
res_dict['TRACKING_ERROR'] = '{0:.4f}'.format(
np.std(strategy_log_returns - benchmark_returns, ddof=1))
percentile = 0.001
res_dict['VaR_99.9'] = '{0:.3f} %'.format(
np.percentile(np.sort(strategy_log_returns), percentile * 100) * 100)
#############################################################################################
# F. Classification scores
sign_positions = np.sign(purchased_shares).flatten()
sign_profits = np.sign(pnl).flatten()
invalid = np.argwhere(np.isnan(sign_positions + sign_profits))
sign_positions_final = np.delete(sign_positions, invalid)
sign_profits_final = np.delete(sign_profits, invalid)
from sklearn.metrics import precision_recall_fscore_support as score
precision, recall, fscore, support = score(sign_profits_final,
sign_positions_final)
decimals = 3
precision = np.round(precision, decimals)
recall = np.round(recall, decimals)
fscore = np.round(fscore, decimals)
support = np.round(support, decimals)
try:
res_dict['CLASSIFICATION_DATA'] = {
'Class': ['-1', '0', '1'],
'Precision': list(precision),
'Recall': list(recall),
'F-Score': list(fscore),
'Support': list(support)
}
res_dict['CLASSIFICATION_DATA'] = pd.DataFrame(
res_dict['CLASSIFICATION_DATA'])
res_dict['CLASSIFICATION_DATA'] = res_dict[
'CLASSIFICATION_DATA'].set_index('Class')
except:
res_dict['CLASSIFICATION_DATA'] = {
'Class': ['-1', '0', '1'],
'Precision': ['NaN', 'NaN', 'NaN'],
'Recall': ['NaN', 'NaN', 'NaN'],
'F-Score': ['NaN', 'NaN', 'NaN'],
'Support': ['NaN', 'NaN', 'NaN']
}
res_dict['CLASSIFICATION_DATA'] = pd.DataFrame(
res_dict['CLASSIFICATION_DATA'])
res_dict['CLASSIFICATION_DATA'] = res_dict[
'CLASSIFICATION_DATA'].set_index('Class')
#############################################################################################
# G. Factor Analysis
import statsmodels.formula.api as sm # module for stats models
from statsmodels.iolib.summary2 import summary_col
def assetPriceReg(excess_ret, fama, t_decimals, coeff_decimals):
df_stock_factor = pd.DataFrame({
'ExsRet': excess_ret,
'MKT': fama[:, 0],
'SMB': fama[:, 1],
'HML': fama[:, 2],
'RMW': fama[:, 3],
'CMA': fama[:, 4]
})
CAPM = sm.ols(formula='ExsRet ~ MKT',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
FF3 = sm.ols(formula='ExsRet ~ MKT + SMB + HML',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
FF5 = sm.ols(formula='ExsRet ~ MKT + SMB + HML + RMW + CMA',
data=df_stock_factor).fit(cov_type='HAC',
cov_kwds={'maxlags': 1})
CAPMtstat = np.round(CAPM.tvalues, t_decimals)
FF3tstat = np.round(FF3.tvalues, t_decimals)
FF5tstat = np.round(FF5.tvalues, t_decimals)
CAPMcoeff = np.round(CAPM.params, coeff_decimals)
FF3coeff = np.round(FF3.params, coeff_decimals)
FF5coeff = np.round(FF5.params, coeff_decimals)
# DataFrame with coefficients and t-stats
results_df = pd.DataFrame(
{
'CAPM_coeff': CAPMcoeff,
'CAPM_tstat': CAPMtstat,
'FF3_coeff': FF3coeff,
'FF3_tstat': FF3tstat,
'FF5_coeff': FF5coeff,
'FF5_tstat': FF5tstat
},
index=['Intercept', 'MKT', 'SMB', 'HML', 'RMW', 'CMA'])
dfoutput = summary_col(
[CAPM, FF3, FF5],
stars=True,
float_format='%0.4f',
model_names=[
'CAPM', 'Fama-French 3 Factors', 'Fama-French 5 factors'
],
info_dict={
'N': lambda x: "{0:d}".format(int(x.nobs)),
'Adjusted R2': lambda x: "{:.4f}".format(x.rsquared_adj)
},
regressor_order=['Intercept', 'MKT', 'SMB', 'HML', 'RMW', 'CMA'])
return dfoutput, results_df
_, res_dict['FACTOR_RES'] = assetPriceReg(excess_returns, fama_factors, 2,
5)
#############################################################################################
# H. Bootstrap Stats
# 1. Sharpe Bootstrap
from arch.bootstrap import MovingBlockBootstrap
from numpy.random import RandomState
def geom_mean(y):
log_ret = np.log(1 + y)
geom = np.exp(np.sum(log_ret) / len(log_ret)) - 1
return geom
geo_avg = geom_mean(strategy_daily_returns)
detrended_ret = strategy_daily_returns - geo_avg
bs_sharpe = MovingBlockBootstrap(5,
detrended_ret,
random_state=RandomState(1234))
res = bs_sharpe.apply(geom_mean, 10000)
# plots.density_plot_bootstrap(res,geo_avg)
p_val = (res <= geo_avg).sum() / len(res)
res_dict['SHARPE_BS'] = res
res_dict['SHARPE_BS_GEOM_AVG'] = str(round(geo_avg, 5))
res_dict['GM_BOOTSTRAP_p_val'] = '{0:.3f} %'.format(p_val * 100)
############################################################################################
return res_dict