def __init__(self, perf_ts, risk_free= 0, z_score = 1.96, folio_name=""):
debug_info("BasicStats perf_ts : %s"%(str(perf_ts)))
self.perf_ts = perf_ts
self.z_score = z_score
self.risk_free = risk_free
freq = get_frequency(self.perf_ts)
self.freq = "Day" if freq == "D" else freq
self.ann_factor = ann_factor[self.freq[0]]
self.sqrt_factor = self.ann_factor ** 0.55
self.tsarr = self.perf_ts.values # [perf["NetReturn"] for perf in perf_ts]
self.tsarr_rf = [float(x) - risk_free / self.ann_factor for x in self.tsarr] if self.ann_factor else []
self.perf_rf = Series(data=self.tsarr_rf, index=self.perf_ts.index)
self.T = len(self.perf_ts)
self.mean = np.mean(self.tsarr)
self.std = np.std(self.tsarr)
self.skew = stats.skew(self.tsarr)
self.kurt = stats.kurtosis(self.tsarr)+3
self.mdd_ser = BasicStats.under_water_series(self.perf_ts)
self.maxdd = min(self.mdd_ser) if self.ann_factor else 0
self.up_returns = [r for r in self.tsarr if r > 0]
self.dn_returns = [r for r in self.tsarr if r < 0]
self.T_UP = len(self.up_returns)
self.T_DN = len(self.dn_returns)
self.pct_up = self.T_UP / float(self.T)
self.pct_dn = self.T_DN / float(self.T)
self.avg_gain = np.mean(self.up_returns)
self.avg_loss = np.mean(self.dn_returns)
self.std_gain = np.std(self.up_returns)
self.std_loss = np.std(self.dn_returns)
self.vami = BasicStats.vami_arr(self.perf_ts)
self.vami_rf = BasicStats.vami_arr(self.perf_rf)
self.cum_return = self.vami[-1] -1
self.cum_return_rf = self.vami_rf[-1] - 1
self.ann_return = ((1+self.cum_return) **(self.ann_factor / self.T) - 1) #if self.T >=365 else self.cum_return / self.T * 365
self.ann_return_rf = (1+self.cum_return_rf) **(self.ann_factor / self.T) - 1 #if self.T >=365 else self.cum_return_rf / self.T * 365
self.ann_std = self.std * np.sqrt(self.ann_factor)
self.std_rf = np.std(self.tsarr_rf)
self.mean_rf = np.mean(self.tsarr_rf)
self.sharpe = self.mean_rf * self.sqrt_factor / self.std_rf
self.var = self.mean - self.z_score * self.std
self.adj_z = adj_z_score(self.z_score, self.skew, self.kurt)
self.var_adj = self.mean - self.adj_z * self.std
self.cvar = cvar(self.tsarr)
self.best = max(self.tsarr)
self.worst = min(self.tsarr)
self.down_dev = self.downside_deviation(self.tsarr_rf)
self.sortino = self.ann_return_rf / (self.std_loss * self.sqrt_factor)
self.sortino_adj = self.ann_return_rf / (self.down_dev * self.sqrt_factor)
X = self.perf_ts[1:].values
X_1 = self.perf_ts[:-1].values
self.ser_df = DataFrame([X,X_1]).transpose()
self.serr_corr = self.ser_df.corr().iloc[0,1]
self.socre = self.sharpe * 5 + self.ann_return * 10 + self.sortino * 5 - self.maxdd * 5
def __init__(self, weights,series):
self.weights = weights
self.series = series
self.mean = mean(series)
self.std = std(series)
self.freq = get_frequency(series)
self.ann_factor = freq_map[self.freq]
self.ann_return = self.mean * self.ann_factor
self.ann_vol = self.std * (self.ann_factor ** 0.5)
def write_coin_stats(coin, i):
wsh.write(i + 1, 3, len(coin.Performance))
if (len(coin.Performance)) > 0:
wsh.write(
i + 1, 4,
min(coin.Performance.index).to_datetime().strftime(
"%m/%d/%Y"))
wsh.write(
i + 1, 5,
max(coin.Performance.index).to_datetime().strftime(
"%m/%d/%Y"))
wsh.write(i + 1, 6, get_frequency(coin.Performance))
def __init__(self, perf_ts, risk_free=0, z_score=1.96):
self.perf_ts = perf_ts
self.z_score = z_score
self.risk_free = risk_free
self.freq = get_frequency(perf_ts)
self.ann_factor = ann_factor[self.freq[0]]
self.sqrt_factor = self.ann_factor**0.5
self.tsarr = perf_ts.values
self.tsarr_rf = [x - risk_free / self.ann_factor for x in self.tsarr]
self.perf_rf = Series(data=self.tsarr_rf, index=self.perf_ts.index)
self.T = len(self.perf_ts)
self.mean = np.mean(self.tsarr)
self.std = np.std(self.tsarr)
self.skew = stats.skew(self.tsarr)
self.kurt = stats.kurtosis(self.tsarr) + 3
self.mdd_ser = BasicStats.under_water_series(self.perf_ts)
self.maxdd = min(self.mdd_ser)
self.up_returns = [r for r in self.tsarr if r > 0]
self.dn_returns = [r for r in self.tsarr if r < 0]
self.T_UP = len(self.up_returns)
self.T_DN = len(self.dn_returns)
self.pct_up = self.T_UP / float(self.T)
self.pct_dn = self.T_DN / float(self.T)
self.avg_gain = np.mean(self.up_returns)
self.avg_loss = np.mean(self.dn_returns)
self.std_gain = np.std(self.up_returns)
self.std_loss = np.std(self.dn_returns)
self.vami = BasicStats.vami_arr(self.perf_ts)
self.vami_rf = BasicStats.vami_arr(self.perf_rf)
self.cum_return = self.vami[-1] - 1
self.cum_return_rf = self.vami_rf[-1] - 1
self.ann_return = (1 + self.cum_return)**(self.ann_factor / self.T) - 1
self.ann_return_rf = (1 + self.cum_return_rf)**(self.ann_factor /
self.T) - 1
self.ann_std = self.std * np.sqrt(self.ann_factor)
self.std_rf = np.std(self.tsarr_rf)
self.mean_rf = np.mean(self.tsarr_rf)
self.sharpe = self.mean_rf * self.sqrt_factor / self.std_rf
self.var = self.mean - self.z_score * self.std
self.adj_z = adj_z_score(self.z_score, self.skew, self.kurt)
self.var_adj = self.mean - self.adj_z * self.std
self.cvar = cvar(self.tsarr)
self.best = max(self.tsarr)
self.worst = min(self.tsarr)
self.down_dev = self.downside_deviation(self.tsarr_rf)
self.sortino = self.ann_return_rf / (self.std_loss * self.sqrt_factor)
self.sortino_adj = self.ann_return_rf / (self.down_dev *
self.sqrt_factor)
X = self.perf_ts[1:].values
X_1 = self.perf_ts[:-1].values
self.ser_df = DataFrame([X, X_1]).transpose()
self.serr_corr = self.ser_df.corr().iloc[0, 1]
def update_portfolio_coin(self, portfolio):
coin = self.get_portfolio_coin(portfolio)
coin.Name = portfolio.Name
coin.StrategyCode = 'Portfolio'
coin.lowername = portfolio.Name.lower()
prof = portfolio.calc_proforma(self)
coin.Performance = prof
coin.T = len(prof)
coin.MaxDate = int(prof.index[-1].timestamp())
coin.Frequency = get_frequency(prof)
self.get_table("Coin").put_item(Item=coin.to_db_item())
return coin
def __init__(self, *, OwnerId=None, Data={}):
self.import_dict(Data)
self.OwnerID = OwnerId if OwnerId else Data['OwnerID']
if 'HashKey' not in self.__dict__:
self.HashKey = str(uuid1())
if "Name" not in self.__dict__:
if "CoinName" in self.__dict__:
self.Name = self.__dict__["CoinName"]
else:
self.Name = "Coin %s" % self.HashKey
if 'IsPortfolio' not in Data:
self.IsPortfolio = False
if 'Frequency' not in Data:
self.Frequency = "M"
float_fields = [
'CoinCAP', 'ManagementFee', 'PerformanceFee', 'ManagerCAP'
]
for field in float_fields:
if hasattr(self, field):
setattr(self, field, float(getattr(self, field)))
else:
setattr(self, field, 0)
if 'Performance' in self.__dict__:
dates = [
datetime.fromtimestamp(p['EffectiveDate'])
for p in self.Performance
]
rets = [float(p["NetReturn"]) for p in self.Performance]
self.Performance = Series(data=rets, index=dates, name=self.Name)
self.Performance.sort_index(inplace=True)
if len(self.Performance) > 3:
self.Frequency = get_frequency(self.Performance)
self.T = len(self.Performance)
else:
self.Performance = Series()
if 'MaxDate' in self.__dict__:
self.MaxDate = datetime.fromtimestamp(self.MaxDate)
if 'MinDate' in self.__dict__:
self.MinDate = datetime.fromtimestamp(self.MinDate)
def __init__(self, series):
self.series = series
if len(series) < 3:
self.freq = 'M'
else:
self.freq = get_frequency(series)
self.month_dict = {}
freq_idx = freq_map[self.freq[0]]
"""
month dict contains peformance data for getting list of date
with perormance for each month. this allows us to drill down into
each month performance
"""
dates = series.index
values = series.values
for d, v in zip(dates, values):
index = d.year * 100 + d.month
if index in self.month_dict:
arr = self.month_dict[index]
arr.append((d.strftime("%m/%d"), "%0.2f" % (v * 100) + "%"))
else:
self.month_dict[index] = [(d.strftime("%m/%d"),
"%0.2f" % (v * 100) + "%")]
if freq_idx == 12:
self.monthly = series
if freq_idx > 12:
self.monthly = series.resample("M").apply(logreturns)
self.annual = series.resample("A").apply(logreturns)
monthly_index = self.monthly.index
self.ann_perf = []
for year_index in self.annual.index:
y = year_index.year
perf = AnnualPerformance(y)
midx = [m for m in monthly_index if m.year == y]
for m in midx:
perf.months[m.month - 1] = self.monthly[m]
perf.ytd = self.annual[year_index]
perf.calc_month_table()
self.ann_perf.append(perf)
self.series.sort_index(inplace=True)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 31 13:11:48 2016
@author: coin-ai
"""
from datalib.datalib import Connection
from datalib.coin import Coin
from datetime import datetime
from analytics.time_series import get_frequency
db = Connection()
COINS = db.get_all_coins()
table = db.get_table("COIN")
for COIN in COINS:
# print(COIN.Name)
ts = COIN.Performance
T = len(ts)
mx = int(max(ts.index).timestamp())
mn = int(min(ts.index).timestamp())
item = COIN.to_db_item()
item['MaxDate'] = mx
item['MinDate'] = mn
item['Frequency'] = get_frequency(ts)
item['T'] = T
table.put_item(Item=item)
# print("COIN updated: %s" % COIN.Name)
