def __init__(self, y, x):
self.ts_y = y
if type(x) is list:
self.ts_x = x
else:
self.ts_x = [x]
self.all_series = self.ts_x.copy()
self.all_series.insert(0, self.ts_y)
self.common_data = align_series(self.all_series)
self.columns = self.common_data.columns
self.Y = self.common_data[self.columns[0]].values
self.X = self.common_data[self.columns[1:]].values
self.X = sm.add_constant(self.X)
self.model = sm.OLS(self.Y, self.X)
self.reg_results = self.model.fit()
betas = list(self.reg_results.params)[1:]
self.betas = [toDecimal(b) for b in betas]
self.pvalues = self.reg_results.pvalues[1:]
self.alpha = self.reg_results.params[0]
self.rsq_adj = self.reg_results.rsquared_adj
self.rsq = self.reg_results.rsquared
self.coin_vol = var(self.Y)
if len(self.ts_x) > 1:
self.factor_cov = cov(self.X[:, 1:], rowvar=False)
betas = [float(betas) for betas in self.betas]
self.fcmtr = matmul(self.factor_cov, betas)
self.crisk = [
b * v / self.coin_vol for (b, v) in zip(betas, self.fcmtr)
]
else:
self.factor_cov = [cov(self.X[:, 1])]
self.crisk = [self.rsq]
self.crisk.append(1 - sum(self.crisk))
self.crisk_cum = cumsum(self.crisk)
def __init__(self,
folio_ts,
peer,
user_id=None,
factors=None,
Index=0,
regime_model=None):
if user_id:
peer_folio_ts = peer.folio_ts
else:
peer_folio_ts = peer.Performance
common_data = align_series([folio_ts, peer_folio_ts])
self.Name = peer.Name
self.entire_return = peer.entire_history if user_id else 0
self.HashKey = peer.folio_id if user_id else peer.coin_id
self.corr = common_data.corr().iloc[0, 1]
self.peer_stats = BasicStats(peer_folio_ts)
self.coin_stats = BasicStats(folio_ts)
self.peer_ts = peer_folio_ts
self.folio_ts = folio_ts
self.index = Index
if factors:
self.factors = factors
self.factor_ts = [f.Performance for f in self.factors]
self.peer_style = RegressionAnalysis(self.peer_ts, self.factor_ts)
else:
self.coin_style = None
self.peer_style = None
if regime_model:
self.regime_stats = RegimeAnalysis(peer, regime_model, peer,
user_id)
self.XY = common_data.values
def calc_proforma(self, db, new_weights=[], update_common_ts=True):
"""
calcualte portfolio proforma time series
"""
if len(self.Allocations) > 0:
get_w = lambda: [float(a['Allocation']) for a in self.Allocations]
weights = new_weights if len(new_weights) > 0 else get_w()
good_weights = [w for w in weights if w > 0]
if update_common_ts:
if not self.coins:
self.coins = self.get_coins(db)
perfs = []
for coin, w in zip(self.coins, weights):
if w > 0:
if len(coin.Performance) == 0:
coin2 = db.get_coin(coin.HashKey, get_ts=True)
coin.Performance = coin2.Performance
else:
perfs.append(coin.Performance)
self.common_ts = align_series(perfs)
ret_m = matrix(self.common_ts.values)
W = matrix(good_weights)
proforma = ret_m * W.T
prof_array = [p[0, 0] for p in proforma]
dates = self.common_ts.index
return Series(data=prof_array, index=dates, name=self.Name)
return Series()
def SimpleReg(y, x, has_const=False):
common_data = align_series([y, x])
y = common_data.iloc[:, 0]
x = common_data.iloc[:, 1]
if has_const:
x = sm.add_constant(x)
model = sm.OLS(y, x)
res = model.fit()
return list(res.params.values)
def calc_tmy(fts, benchts):
common_data = align_series([fts, benchts])
common_data.columns = ['Y', 'X']
common_data['XY'] = common_data['X']**2
y = common_data.iloc[:, 0].values
x = common_data.iloc[:, 1:].values
x = sm.add_constant(x)
model = sm.OLS(y, x)
res = model.fit()
return res.params
def __init__(self, ts, bench_ts):
"""
Constructor accepts to Series objects (for Coin and benchmark)
"""
self.common_df = align_series([ts, bench_ts])
self.data = self.common_df.values
self.bench_data = self.data[:, 1]
self.coin_data = self.data[:, 0]
self.idx_bench_up = self.bench_data > 0
self.idx_bench_dn = self.bench_data < 0
self.T = len(self.bench_data)
self.T_Up = len([i for i in self.idx_bench_up if i])
self.T_Dn = len([i for i in self.idx_bench_dn if i])
self.coin_bench = self.coin_data - self.bench_data
self.coin_bench_up = self.coin_bench[self.idx_bench_up]
self.coin_bench_dn = self.coin_bench[self.idx_bench_dn]
reg_up = self.calc_beta(self.coin_data, self.bench_data,
self.idx_bench_up)
reg_dn = self.calc_beta(self.coin_data, self.bench_data,
self.idx_bench_dn)
self.alpha_up = reg_up[0]
self.alpha_dn = reg_dn[0]
self.beta_up = reg_up[1]
self.beta_dn = reg_dn[1]
if self.T_Up > 0:
self.up_capture = self.calc_capture(self.coin_data,
self.bench_data,
self.idx_bench_up)
self.T_Up_outperf = len([f for f in self.coin_bench_up if f > 0])
self.up_outperf = self.T_Up_outperf / self.T_Up
self.perf_bench_up = self.coin_bench_up.mean()
self.bench_up = self.bench_data[self.idx_bench_up].mean()
else:
self.up_outperf = 0
if self.T_Dn > 0:
self.dn_capture = self.calc_capture(self.coin_data,
self.bench_data,
self.idx_bench_dn)
self.T_Dn_outperf = len([f for f in self.coin_bench_dn if f > 0])
self.dn_outperf = self.T_Dn_outperf / self.T_Dn
self.perf_bench_dn = self.coin_bench_dn.mean()
self.bench_dn = self.bench_data[self.idx_bench_dn].mean()
else:
self.dn_outperf = 0
async def populate_time_series(self, start_at=None):
"""
Get a set of common time series based on item and benchmarks (if any)
"""
self.all_series = [self.perf]
if 'Benchmarks' in self.item.__dict__:
self.benchmarks = self.item.Benchmarks
for ticker in self.item.Benchmarks:
bench = await self.db.get_risk_factor(ticker, start_at)
if bench:
if len(bench.Performance) > 0:
self.all_series.append(bench.Performance)
self.data_frame = align_series(self.all_series)
else:
self.benchmarks = []
self.n_benchmarks = 0
self.data_frame = DataFrame(self.perf)
def __init__(self, ts, bench_ts):
self.ts = ts
self.bench_ts = bench_ts
self.common_data = align_series([self.ts, self.bench_ts])
self.columns = self.common_data.columns
self.idx_up = self.common_data[self.columns[1]] > 0
self.idx_dn = self.common_data[self.columns[1]] < 0
self.data_up = self.common_data[self.idx_up]
self.data_dn = self.common_data[self.idx_dn]
self.XY = self.common_data.values
self.T = len(self.common_data)
if len(self.common_data) >= 6:
self.corr = self.common_data.corr().iloc[1, 0]
if len(self.data_up) >= 6:
self.corr_up = self.data_up.corr().iloc[1, 0]
if len(self.data_dn) >= 6:
self.corr_dn = self.data_dn.corr().iloc[1, 0]
