ratchet

Author: microprediction

Diff for: precise/skaters/covariance/bufsk.py

@@ -4,12 +4,10 @@
 from sklearn.covariance import GraphicalLasso, GraphicalLassoCV, LedoitWolf, MinCovDet, OAS, EmpiricalCovariance
 
 
-# Sklearn
+# A collection of "online" covariance skaters that just call down to batch-style
+# sklearn covariance estimators (so not terribly efficient) evaluated on a buffer.
 
 
-    
- 
-
 def buf_sk_emp_pcov_d0_n100(y: X_TYPE = None, s: dict = None, k=1, e=1):
     """ Sklearn empirical covariancecomparisonutil based estimator for IID observations """
     assert k == 1
@@ -77,7 +75,6 @@ def buf_sk_glcv_pcov_d0_n100_t0(y: X_TYPE = None, s: dict = None, k=1, e=1):
     return buf_sk_factory(cls=GraphicalLassoCV, y=y, s=s, n_buffer=100, n_emp=30, cls_kwargs=cls_kwargs, e=e)
 
 
-
 def buf_sk_glcv_pcov_d0_n200(y: X_TYPE = None, s: dict = None, k=1, e=1):
     """ Graphical Lasso CV covariancecomparisonutil based estimator for IID observations """
     assert k == 1
@@ -186,10 +183,10 @@ def buf_sk_oas_pcov_d1_n300(y: X_TYPE = None, s: dict = None, k=1, e=1):
     return d1_factory(f=buf_sk_oas_pcov_d0_n300, y=y, s=s, k=1, e=e)
 
 
-def buf_sk_gl_pcov_d1_n100(y: X_TYPE = None, s: dict = None, n_buffer: int = 100, k=1, e=1):
+def buf_sk_gl_pcov_d1_n100(y: X_TYPE = None, s: dict = None, k=1, e=1):
     """ GL based estimator for IID changes  """
     assert k == 1
-    return d1_factory(f=buf_sk_gl_pcov_d0_n100, y=y, s=s, n_buffer=n_buffer, e=e)
+    return d1_factory(f=buf_sk_gl_pcov_d0_n100, y=y, s=s,  e=e)
 
 
 def buf_sk_glcv_pcov_d1_n100(y: X_TYPE = None, s: dict = None, k=1, e=1):

Diff for: precise/skaters/managers/buyandholdfactory.py

@@ -44,7 +44,7 @@ def buy_and_hold_manager_factory(mgr, j: int, y, s: dict, e=1000, q=1.0):
             s_mgr = s['s_mgr']
             _ignore_w, s_mgr = mgr(y=y, s=s_mgr, e=-1)
             s['s_mgr'] = s_mgr
-            # ... instead we let it ride
+            # ... instead we just hold the assets
             w_prev = s['w']
             w = normalize([wi * math.exp(yi) for wi, yi in zip(w_prev, y)])
             s['w'] = [wi for wi in w]

Diff for: precise/skaters/managers/ratchetfactory.py

@@ -0,0 +1,81 @@
+
+import math
+from precise.skaters.locationutil.vectorfunctions import normalize
+from copy import deepcopy
+import numpy as np
+
+
+def index_of_closest(w, ws):
+    l1s = [ sum(abs(np.array(w)-np.array(wsi))) for wsi in ws ]
+    return l1s.index(min(l1s))
+
+
+def ratchet_manager_factory(mgr, y, s:dict, e=-1, j:int=1000000, q=0.8, vup=1.1, vdn=0.85):
+    """
+
+        Sets a new target weight when either s['count'] % j = 0 or e>0
+        Otherwise, we use the stale target and ratchet towards it.
+
+        For this to make any sense, 'y' must be changes in log prices.
+        The manager must respect the "e" convention. That is, the
+                                    manager must do little work when e<0
+
+    :param mgr:            Any "manager"
+    :param y:
+    :param s:              State
+    :param e:              If e>0 is send, this will be passed to the manager and we assume a full update
+    :param j:
+    :param q:              New portfolio is  q*w + (1-q)*w_prev
+    :param vup:            Upper multiplier of target weights
+    :param vdn:            Lower multiplier of target weights
+    :param n_seed          Number of times to call the manager repeatedly with (almost) the same state
+    :param mgr_kwargs:
+    :return:  w   Portfolio weights
+    """
+    if s.get('w') is None:
+        # Initialization
+        s['count'] = 0
+        s_mgr = {}
+        w, s_mgr = mgr(y=y, s=s_mgr, e=1000)
+        s['s_mgr'] = s_mgr
+        s['w'] = w
+        return w, s
+    else:
+        s['count'] = s['count']+1
+        if (s['count'] % j == 0) or (e>0):
+            # Sporadically use the manager to change the target weights
+            s_mgr = s['s_mgr']
+            s['w_target'] = mgr(y=y, s=s_mgr, e=e)
+
+            # Buy and hold
+            w_prev = s['w']
+            w_roll = normalize([wi * math.exp(yi) for wi, yi in zip(w_prev, y)])
+
+            # Use the last call to set new manager state.
+            s['s_mgr'] = s_mgr
+
+            # Then move towards target
+            w = [ wi*q + (1-q)*wpi for wi, wpi in zip(s['w_target'], w_roll) ]
+            s['w'] = [wi for wi in w]
+            return w, s
+        else:
+            # Tell the manager not to worry too much about this data point, as the weights won't be used
+            s_mgr = s['s_mgr']
+            _ignore_w, s_mgr = mgr(y=y, s=s_mgr, e=e)
+            s['s_mgr'] = s_mgr
+            # ... instead we let it ride
+            w_prev = s['w']
+            w_roll = normalize( [ wi*math.exp(yi) for wi,yi in zip(w_prev,y)] )
+
+            # Now we ratchet by generating possible trades outside the no-trade zone
+            w_upper = [ wi*vup for wi in s['w_target']]
+            w_lower = [ wi*vdn for wi in s['w_target']]
+
+            # Convert trade list to weight changes
+            from precise.skaters.managerutil.ratcheting import ratchet_trades
+            dw = ratchet_trades(w=w_roll, w_lower=w_lower, w_upper=w_upper)
+            w = [wi+dwi for wi,dwi in zip(w_roll,dw )]
+
+            return w, s
+
+

Diff for: precise/skaters/managerutil/ratcheting.md

@@ -0,0 +1,85 @@
+
+
+def ratchet_trades(w, w_lower, w_upper, min_dw:float=1e-6)->[float]:
+    """
+         Given a current portfolio w, and upper and lower envelopes, this
+         procedure will try to construct a list of allocation adjustments dw summing
+         to zero that take w to a new portfolio w+dw that is closer to satisfying
+
+                   w_lower <= w + dw <= w_upper
+
+         The algorithm is somewhat heuristic but motivated by results suggesting a
+         no-trade region for portfolios managed on a continuous basis in the presence of
+         trading costs.
+
+
+    :param w:             Current portfolio
+    :param w_lower:       Lower envelope
+    :param w_upper:       Upper envelope
+    :param min_dw:        Minimum size of a reallocation
+    :return: dw:          Trades that move w towards envelope
+    """
+
+    # Create a list of sell and buy opportunities (size, direction, ndx) in decreasing size
+    sells = sorted(
+        [[max(0, wi - wui), -1, i] for i, (wi, wui) in enumerate(zip(w, w_upper)) if (wi > wui + min_dw)],
+        reverse=True)
+    buys = sorted(
+        [[max(0, wli - wi), 1, i] for i, (wi, wli) in enumerate(zip(w, w_lower)) if (wli - wi > min_dw)],
+        reverse=True)
+
+    if len(sells):
+        trades = [sells.pop(0)]
+    elif len(buys):
+        trades = [buys.pop(0)]
+    else:
+        # We're already in the envelope
+        return [0 for _ in w]
+
+    # Walk down the queues and greedy balance buys and sells
+    while True:
+        net = sum([trade[0] * trade[1] for trade in trades])
+        if (net > 0):
+            # We have been net buyers thus far
+            if len(sells) == 0:
+                break
+            else:
+                trades.append(sells.pop(0))
+        else:
+            # We have been net sellers thus far
+            if len(buys) ==0:
+                break
+            else:
+                trades.append(buys.pop(0))
+
+    # Walk back up and balance
+    pos = len(trades)-1
+    while True:
+        tr = trades[pos]
+        tr_dir = tr[1]
+        if ((net > 0) and (tr_dir>0)) or ((net < 0) and (tr_dir<0)):
+            trades[pos][0] = trades[pos][0] - abs(net)
+            break
+        else:
+            pos = pos-1
+
+    # Kill zero trades
+    trades = [ tr for tr in trades if abs(tr[1])>1e-9 ]
+
+    # Convert back to trades
+    dw = [0 for _ in w ]
+    for tr in trades:
+        dw[tr[2]] = tr[0]*tr[1]
+    return dw
+
+
+
+
+if __name__=='__main__':
+    w = [0.1, 0.2, 0.1, 0.05, 0.025, 0.1, 0.025, 0.3, 0.1]
+    w_lower = [0.075]*len(w)
+    w_upper = [0.125]*len(w)
+    dw = ratchet_trades(w=w,w_lower=w_lower,w_upper=w_upper)
+
+
+

Diff for: precise/skaters/managerutil/ratcheting.py

@@ -36,6 +36,7 @@ def rel_entropish(w):
     """ Always non-positive """
     return entropish(w) - max_entropish(w)
 
+
 def scaled_entropish(w):
     return rel_entropish(w)/rel_entropish_like(w)
 

Diff for: precise/skaters/portfoliostatic/weakportfactory.py

@@ -7,8 +7,8 @@
 
 setup(
     name="precise",
-    version="0.13.4",
-    description="Online covariancecomparisonutil, precision, portfolios and ensembles",
+    version="0.13.5",
+    description="The home of Schur Hierarchical Portfolios: an aesthetically pleasing version of Hierarchical Risk Parity",
     long_description=README,
     long_description_content_type="text/markdown",
     url="https://github.com/microprediction/precise",

Diff for: setup.py

@@ -6,7 +6,7 @@ def test_random_schur_manager():
     from precise.skaters.managers.schurmanagers import schur_diag_weak_pm_t0_r050_n25_s5_g010_l21_long_manager as mgr
     j = random.choice([1, 5, 20])
     q = random.choice([1.0, 0.1])
-    manager_debug_run(mgr=mgr,j=j, q=q, n_obs=500,n_dim=67)
+    manager_debug_run(mgr=mgr,j=j, q=q, n_obs=50,n_dim=17)
     print(mgr.__name__+' ran  okay')
 
 

Diff for: tests/managers/test_schur_l21.py

@@ -0,0 +1,56 @@
+from precise.skaters.managerutil.ratcheting import ratchet_trades
+import numpy as np
+
+
+def test_ratchet_trades_with_no_opportunity():
+    w = [5/15, 5/15, 5/15]
+    w_upper = [6/15, 6/15, 6/15]
+    w_lower = [4/15, 4/15, 4/15]
+    min_dw = 2
+    expected_output = [0, 0, 0]
+    assert ratchet_trades(w, w_lower, w_upper, min_dw) == expected_output
+
+
+def test_ratchet_trades_with_opportunity():
+    w       = [7/21, 7/21, 7/21]
+    w_upper = [10/21, 6/21, 10/21]
+    w_lower = [8/21,  4/21, 8/21]
+    min_dw = 0.1
+    dw = ratchet_trades(w, w_upper, w_lower, min_dw)
+    assert dw[1]<0
+    assert dw[2]>0
+
+
+def test_ratchet_trades_with_mixed_opportunity():
+    w       = [1/7, 3/7, 3/7]
+    w_upper = [6/7, 6/7, 2/7]
+    w_lower = [2/7, 4/7, 1/7]
+    min_dw = 0.1
+    dw = ratchet_trades(w, w_lower, w_upper, min_dw)
+    assert dw[0]+dw[1]>0
+    assert dw[2]<0
+
+
+
+def test_random():
+    w = sorted(np.random.rand(50))
+    w = w/sum(w)
+
+    w_ = np.random.rand(50)
+    w_ = w_ / sum(w_)
+
+    w_upper = 1.01*w_
+    w_lower = 0.99*w_
+
+    dw = ratchet_trades(w=w, w_lower=w_lower, w_upper=w_upper, min_dw=0.001)
+    assert abs(sum(dw))<1e-6 
+
+
+
+
+
+if __name__=='__main__':
+    test_random()
+    test_ratchet_trades_with_mixed_opportunity()
+    test_ratchet_trades_with_opportunity()
+    test_ratchet_trades_with_no_opportunity()