randomization

Author: microprediction

precise/skaters/managers/buyandchoosefactory.py

@@ -0,0 +1,85 @@
+
+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 buy_and_choose_manager_factory(mgr, j:int, y, s:dict, e=1000, q=1.0, n_seed=5):
+    """ Every j data points, call mgr repeatedly with identical state then most q towards closest weights
+        This won't have any effect on purely deterministic managers, except to slow them down
+        However stochastic managers might benefit, as might others who anticipate an obscure
+        convention: namely the receipt of a 'choose_hint' field in the state
+
+         For this to make any sense, 'y' must be changes in log prices.
+         For this to be efficient, the manager must respect the "e" convention. That is, the
+                                    manager must do little work when e<0
+
+    :param mgr:
+    :param j:
+    :param y:
+    :param s:              State
+    :param q:              New portfolio is  q*w + (1-q)*w_prev
+    :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:
+            # Sporadically use the manager repeatedly.
+
+            w_prev = s['w']
+            w_roll = normalize([wi * math.exp(yi) for wi, yi in zip(w_prev, y)])
+
+            w_mgrs = list()
+            for l in n_seed:
+                s_mgr = deepcopy(s['s_mgr'])
+
+                # Drop a hint to the manager, just in case it is alert
+                # to this obscure convention. If by chance these fields
+                # already exist, don't clobber
+                if '_seed' in s_mgr or '_seed_max' in s_mgr:
+                    raise ValueError('Warning: managers uses a _seed field so is not compatible with buy_and_choose_manager_factory')
+                else:
+                    s_mgr['_seed'] = l
+                    s_mgr['_seed_max'] = n_seed - 1
+
+                w_mgr, s_mgr = mgr(y=y, s=s_mgr, e=1000)
+                w_mgrs.append(w_mgr)
+            # Use the last call to set new manager state.
+            s['s_mgr'] = s_mgr
+
+            # Now select the closest weights in L1-norm to the current portfolio
+            pos = index_of_closest(w_roll,w_mgrs)
+            w_mgr = w_mgrs[pos]
+
+            # Then move towards it.
+            w = [ wi*q + (1-q)*wpi for wi, wpi in zip(w_mgr, 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=-1)
+            s['s_mgr'] = s_mgr
+            # ... instead we let it ride
+            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]
+            return w, s
+
+

precise/skaters/managers/buyandholdfactory.py

@@ -1,19 +1,6 @@
 
 import math
 from precise.skaters.locationutil.vectorfunctions import normalize
-from functools import partial, update_wrapper
-
-
-def buy_and_hold(mgr, j, q=1.0):
-    """ Make a manager with frequency j
-    :param mgr:
-    :param j:
-    :return:
-    """
-    mgr_j_q = partial(mgr,j=j, q=q)
-    mgr_j_q = update_wrapper(mgr_j_q, mgr)
-    mgr_j_q.__name__ = mgr.__name__+'_j'+str(j)+'_q'+str(int(100*q)).zfill(3)
-    return mgr_j_q
 
 
 

precise/skaters/managers/covmanagerfactory.py

@@ -6,7 +6,12 @@
 
 
 
-def _buy_and_hold_port(port, j:int, q:float, y, s:dict, cov, port_kwargs):
+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 _buy_and_hold_and_choose_port(port, j:int, q:float, l:int, y, s:dict, cov, port_kwargs):
     """
 
          Sporadically calls port() but uses buy and hold in between.
@@ -30,10 +35,19 @@ def _buy_and_hold_port(port, j:int, q:float, y, s:dict, cov, port_kwargs):
     else:
         s['count'] = s['count']+1
         if s['count'] % j == 0:
-            # Create a compromise between the roll forward portfolio and what the optimizer wants
+            # Compute roll forward weights
             s['multiplier'] = [mi * math.exp(yi) for mi, yi in zip(s['multiplier'], y)]
             w_roll = normalize([wi * mi for wi, mi in zip(s['w'], s['multiplier'])])
-            w_port = port(cov=cov, **port_kwargs)
+
+            # Run the portfolio optimizer a few times and pick portfolio closest to prior
+            if l is None:
+                w_port = port(cov=cov, **port_kwargs)
+            else:
+                w_ports = [ port(cov=cov, **port_kwargs) for _ in range(l) ]
+                choice = index_of_closest(w_roll, w_ports)
+                w_port = list(w_ports[choice])
+
+            # Create a compromise between the roll forward portfolio and what the optimizer wants
             w = [q * wi + (1 - q) * wpi for wi, wpi in zip(w_port, w_roll)]
             s['w'] = [wi for wi in w]
             s['multiplier'] = [1 for _ in range(n_dim)]
@@ -45,7 +59,7 @@ def _buy_and_hold_port(port, j:int, q:float, y, s:dict, cov, port_kwargs):
             return w, s
 
 
-def static_cov_manager_factory_d0(y, s, f, port, e=1, f_kwargs:dict=None, port_kwargs:dict=None, n_cold=5, zeta=0.0, j=1,q=1.0):
+def static_cov_manager_factory_d0(y, s, f, port, e=1, f_kwargs:dict=None, port_kwargs:dict=None, n_cold=5, zeta=0.0, j=1,q=1.0, l=None):
     """
        Basic manager pattern ignoring mean.
        Expects to receive changes in log(price).
@@ -57,6 +71,7 @@ def static_cov_manager_factory_d0(y, s, f, port, e=1, f_kwargs:dict=None, port_k
           :param zeta  Compromise between cov and corr portfolio (zeta=0, use cov only)
           :param j     How often to run the static portfolio construction.
                        (Warning: if j>1 this will be nonsense unless 'y' represents changes in log prices)
+          :param l     How many times to run the static portfolio construction
 
        :returns w, s
     """
@@ -76,11 +91,11 @@ def static_cov_manager_factory_d0(y, s, f, port, e=1, f_kwargs:dict=None, port_k
     s['count']+=1
     if s['count']>=n_cold and (e>0):
         s_account = s['account_state']
-        w, s_account = _buy_and_hold_port(port=port, y=y, j=j, q=q, s=s_account, cov=x_cov, port_kwargs=port_kwargs)
+        w, s_account = _buy_and_hold_and_choose_port(port=port, y=y, j=j, q=q, l=l, s=s_account, cov=x_cov, port_kwargs=port_kwargs)
         s['account_state'] = s_account
         if zeta is not None and (zeta>0):
             # Drags towards the portfolio determined by cov
-            # FIXME: This should be moved inside _buy_and_hold_port
+            # FIXME: This should be moved inside _buy_and_hold_and_choose_port
             x_diag = np.diag(x_cov)
             x_corr = cov_to_corrcoef(x_cov)
             w_corr_raw = port(cov=x_corr, **port_kwargs)

precise/skaters/managers/hrpmanagers.py

@@ -26,12 +26,17 @@ def hrp_weak_vol_ewa_r025_n50_s50_long_manager(y, s, k=1, e=1,j=1,q=1.0):
     return schur_weak_vol_ewa_manager_factory(y=y, s=s, r=0.025, n_emp=50, n_split=50, e=e, gamma=0, delta=0,j=j,q=q)
 
 
+def hrp_weak_vol_ewa_r025_n50_s50_l10_long_manager(y, s, k=1, e=1,j=1,q=1.0):
+    assert k==1
+    return schur_weak_vol_ewa_manager_factory(y=y, s=s, r=0.025, n_emp=50, n_split=50, e=e, gamma=0, delta=0,j=j,q=q,l=10)
+
 
 
 HRP_LONG_MANAGERS = [ hrp_weak_weak_pm_t0_d0_r025_n50_s5_long_manager,
                       hrp_vol_vol_pm_t0_d0_r025_n50_s5_long_manager,
                       hrp_vol_vol_pm_t0_d0_r025_n50_s50_long_manager,
-                      hrp_weak_vol_ewa_r025_n50_s50_long_manager
+                      hrp_weak_vol_ewa_r025_n50_s50_long_manager,
+                      hrp_weak_vol_ewa_r025_n50_s50_l10_long_manager
                       ]
 HRP_LS_MANAGERS = []
 HRP_MANAGERS = HRP_LONG_MANAGERS + HRP_LS_MANAGERS

precise/skaters/managers/schurmanagerfactory.py

@@ -214,7 +214,7 @@ def schur_vol_vol_pm_manager_factory(y, s, n_emp, e, r, target=0, n_split=5, gam
 
 
 
-def schur_weak_vol_ewa_manager_factory(y, s, n_emp, e, r, n_split=5, a=1.0, b=None, gamma=0.0, delta=0, zeta=0,j=1,q=1.0):
+def schur_weak_vol_ewa_manager_factory(y, s, n_emp, e, r, n_split=5, a=1.0, b=None, gamma=0.0, delta=0, zeta=0,j=1,q=1.0,l=None):
     """
        Schur with weak allocation and min-vol portfolio construction  using expon weighted cov estimation
            a, b             - weak coefs used at leaf
@@ -223,5 +223,5 @@ def schur_weak_vol_ewa_manager_factory(y, s, n_emp, e, r, n_split=5, a=1.0, b=No
     alloc = partial( weak_allocation_factory,a=a, b=b )
     leaf_port = partial( ppo_vol_port )
     sch_port = partial( schur_portfolio_factory, alloc=alloc, port=leaf_port, n_split=n_split, gamma=gamma, delta=delta)
-    return static_cov_manager_factory_d0(f=f, port=sch_port, y=y, s=s, e=e, zeta=zeta,j=j,q=q)
+    return static_cov_manager_factory_d0(f=f, port=sch_port, y=y, s=s, e=e, zeta=zeta,j=j,q=q,l=l)
 

precise/skaters/managers/schurmanagers.py

@@ -1,12 +1,8 @@
 from precise.skaters.managers.schurmanagerfactory import schur_weak_weak_pm_manager_factory, schur_weak_weak_ewa_manager_factory, \
     schur_diag_weak_pm_manager_factory, schur_vol_vol_ewa_manager_factory, schur_weak_vol_ewa_manager_factory, schur_diag_diag_ewa_manager_factory
-from precise.skaters.managers.buyandholdfactory import buy_and_hold
 from precise.skaters.managers.schurmanagerfactory import schur_vol_vol_pm_manager_factory
 
 
-
-USE_JS = False
-
 # gamma = 1.0
 # r=0.025...
 
@@ -369,14 +365,6 @@ def schur_diag_weak_pm_t0_r050_n25_s5_g000_long_manager(y, s, k=1,e=1, j=1,q=1.0
 SCHUR_J1_LONG_MANAGERS = SCHUR_GAMMA_100_LONG_MANAGERS + SCHUR_GAMMA_050_LONG_MANAGERS + SCHUR_GAMMA_010_LONG_MANAGERS + SCHUR_GAMMA_000_LONG_MANAGERS
 SCHUR_LS_MANAGERS = []
 
-# Remark: Functions not defined at top level don't always play nice with multiprocessing
-if USE_JS:
-    SCHUR_J5_LONG_MANAGERS = [ buy_and_hold(mgr,j=5) for mgr in SCHUR_J1_LONG_MANAGERS ]
-    SCHUR_J20_LONG_MANAGERS = [ buy_and_hold(mgr,j=20) for mgr in SCHUR_J1_LONG_MANAGERS ]
-else:
-    SCHUR_J5_LONG_MANAGERS = []
-    SCHUR_J20_LONG_MANAGERS = []
-
-SCHUR_LONG_MANAGERS = SCHUR_J1_LONG_MANAGERS + SCHUR_J5_LONG_MANAGERS + SCHUR_J20_LONG_MANAGERS
+SCHUR_LONG_MANAGERS = SCHUR_J1_LONG_MANAGERS
 
 SCHUR_MANAGERS = SCHUR_LONG_MANAGERS + SCHUR_LS_MANAGERS

precise/skaters/managers/weakmanagers.py

@@ -1,7 +1,7 @@
 from precise.skaters.managers.weakmanagerfactory import weak_pm_manager_factory, weak_ewa_manager_factory, weak_manager_factory
 from precise.skaters.covariance.bufsk import buf_sk_glcv_pcov_d0_n100, buf_sk_glcv_pcov_d0_n100_t0, buf_sk_lw_pcov_d0_n100, buf_sk_mcd_pcov_d0_n100, buf_sk_lw_pcov_d1_n100
 from precise.skaters.portfoliostatic.weakportfactory import BIG_H
-from precise.skaters.managers.buyandholdfactory import buy_and_hold
+from precise.skaters.managerutil.buyandhold import buy_and_hold
 
 USE_JS = False
 

precise/skaters/managerutil/buyandhold.py

@@ -0,0 +1,15 @@
+from functools import partial, update_wrapper
+
+
+def buy_and_hold(mgr, j, q=1.0):
+    """
+        Use this to make a canonically named manager with j and q fixed that does not expect j, q arguments
+
+    :param mgr:
+    :param j:
+    :return:
+    """
+    mgr_j_q = partial(mgr,j=j, q=q)
+    mgr_j_q = update_wrapper(mgr_j_q, mgr)
+    mgr_j_q.__name__ = mgr.__name__+'_j'+str(j)+'_q'+str(int(100*q)).zfill(3)
+    return mgr_j_q

precise/skaters/portfolioutil/portfunctions.py

@@ -70,13 +70,22 @@ def exclude_negative_weights(w, with_neg_mass=False):
         return (w_pos, neg_mass) if with_neg_mass else w_pos
 
 
-def var_scaled_returns(cov, mu:float, r:float):
+def var_scaled_returns(cov, mu:float, r:float, noise=0.01):
+    """ Set returns as function of variance.
+        Plenty of quibbles here.
+    :param cov:
+    :param mu:
+    :param r:
+    :param noise:
+    :return:
+    """
     import warnings
     warnings.filterwarnings('error')
     vars = np.diag(cov)
     typical_var = np.mean(vars)
+
     try:
-        result = r+(mu-r)*np.array([ v/typical_var for v in vars])
+        result = r+(mu-r)*np.array([ v/typical_var*(1+np.random.rand()*noise) for v in vars])
     except RuntimeWarning as e:
         print(e)
         pass

setup.py

@@ -7,7 +7,7 @@
 
 setup(
     name="precise",
-    version="0.10.0",
+    version="0.10.1",
     description="Online covariance, precision, portfolios and ensembles",
     long_description=README,
     long_description_content_type="text/markdown",