add more optimizers

Author: jialuechen

deepfolio/optimizers/black_litterman_optimization.py

@@ -0,0 +1,73 @@
+import tensorflow as tf
+import numpy as np
+import cvxpy as cp
+
+class BlackLittermanOptimizer(tf.keras.layers.Layer):
+    def __init__(self, n_assets, risk_aversion=2.5, tau=0.05):
+        super(BlackLittermanOptimizer, self).__init__()
+        self.n_assets = n_assets
+        self.risk_aversion = risk_aversion
+        self.tau = tau
+
+    def call(self, inputs):
+        market_caps, Sigma, views, view_confidences = inputs
+        
+        def black_litterman_optimization(market_caps, Sigma, views, view_confidences):
+            # Calculate market equilibrium returns
+            market_weights = market_caps / np.sum(market_caps)
+            Pi = self.risk_aversion * Sigma @ market_weights
+
+            # Prepare views
+            P = np.eye(self.n_assets)[views[:, 0].astype(int)]
+            Q = views[:, 1]
+            Omega = np.diag(1 / view_confidences)
+
+            # Black-Litterman formula
+            BL_mean = np.linalg.inv(np.linalg.inv(self.tau * Sigma) + P.T @ np.linalg.inv(Omega) @ P) @ \
+                      (np.linalg.inv(self.tau * Sigma) @ Pi + P.T @ np.linalg.inv(Omega) @ Q)
+            BL_cov = np.linalg.inv(np.linalg.inv(self.tau * Sigma) + P.T @ np.linalg.inv(Omega) @ P)
+
+            # Optimization
+            w = cp.Variable(self.n_assets)
+            risk = cp.quad_form(w, BL_cov)
+            ret = BL_mean.T @ w
+            objective = cp.Maximize(ret - self.risk_aversion * risk)
+            constraints = [cp.sum(w) == 1, w >= 0]
+
+            prob = cp.Problem(objective, constraints)
+            try:
+                prob.solve(solver=cp.SCS)
+                if prob.status != cp.OPTIMAL:
+                    raise ValueError('Optimization problem not solved optimally')
+                return w.value
+            except:
+                return market_weights
+
+        optimized_w = tf.py_function(
+            func=black_litterman_optimization,
+            inp=[market_caps, Sigma, views, view_confidences],
+            Tout=tf.float32
+        )
+        
+        return optimized_w
+
+class BlackLittermanDiffOptPortfolio(tf.keras.Model):
+    def __init__(self, input_dim, n_assets, hidden_dim, risk_aversion=2.5, tau=0.05):
+        super(BlackLittermanDiffOptPortfolio, self).__init__()
+        self.feature_extractor = tf.keras.Sequential([
+            tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(input_dim,)),
+            tf.keras.layers.Dense(hidden_dim, activation='relu')
+        ])
+        self.market_cap_predictor = tf.keras.layers.Dense(n_assets)
+        self.sigma_predictor = tf.keras.layers.Dense(n_assets * n_assets)
+        self.views_predictor = tf.keras.layers.Dense(n_assets * 2)
+        self.view_confidence_predictor = tf.keras.layers.Dense(n_assets)
+        self.bl_optimizer = BlackLittermanOptimizer(n_assets, risk_aversion, tau)
+    
+    def call(self, inputs):
+        features = self.feature_extractor(inputs)
+        market_caps = tf.exp(self.market_cap_predictor(features))  # Ensure positive market caps
+        sigma = tf.reshape(self.sigma_predictor(features), (-1, self.n_assets, self.n_assets))
+        views = tf.reshape(self.views_predictor(features), (-1, self.n_assets, 2))
+        view_confidences = tf.exp(self.view_confidence_predictor(features))  # Ensure positive confidences
+        return self.bl_optimizer([market_caps, sigma, views, view_confidences])

deepfolio/optimizers/cvar_optimization.py

@@ -0,0 +1,62 @@
+import tensorflow as tf
+import cvxpy as cp
+import numpy as np
+
+class CVaROptimizer(tf.keras.layers.Layer):
+    def __init__(self, n_assets, n_scenarios, alpha=0.95):
+        super(CVaROptimizer, self).__init__()
+        self.n_assets = n_assets
+        self.n_scenarios = n_scenarios
+        self.alpha = alpha
+
+    def call(self, inputs):
+        returns_scenarios, = inputs
+        
+        def solve_cvar_optimization(returns_scenarios):
+            w = cp.Variable(self.n_assets)
+            aux_var = cp.Variable(1)
+            slack_vars = cp.Variable(self.n_scenarios)
+            
+            portfolio_returns = returns_scenarios @ w
+            objective = aux_var - (1 / (self.n_scenarios * (1 - self.alpha))) * cp.sum(slack_vars)
+            
+            constraints = [
+                cp.sum(w) == 1,
+                w >= 0,
+                slack_vars >= 0,
+                slack_vars >= -portfolio_returns - aux_var
+            ]
+            
+            prob = cp.Problem(cp.Maximize(objective), constraints)
+            
+            try:
+                prob.solve(solver=cp.SCS)
+                if prob.status != cp.OPTIMAL:
+                    raise ValueError('Optimization problem not solved optimally')
+                return w.value
+            except:
+                # Fallback to equal-weight portfolio if optimization fails
+                return np.ones(self.n_assets) / self.n_assets
+
+        optimized_w = tf.py_function(
+            func=solve_cvar_optimization,
+            inp=[returns_scenarios],
+            Tout=tf.float32
+        )
+        
+        return optimized_w
+
+class CVaRDiffOptPortfolio(tf.keras.Model):
+    def __init__(self, input_dim, n_assets, n_scenarios, hidden_dim, alpha=0.95):
+        super(CVaRDiffOptPortfolio, self).__init__()
+        self.feature_extractor = tf.keras.Sequential([
+            tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(input_dim,)),
+            tf.keras.layers.Dense(hidden_dim, activation='relu')
+        ])
+        self.returns_scenarios_generator = tf.keras.layers.Dense(n_assets * n_scenarios)
+        self.cvar_optimizer = CVaROptimizer(n_assets, n_scenarios, alpha)
+    
+    def call(self, inputs):
+        features = self.feature_extractor(inputs)
+        returns_scenarios = tf.reshape(self.returns_scenarios_generator(features), (-1, self.n_scenarios, self.n_assets))
+        return self.cvar_optimizer([returns_scenarios])

deepfolio/optimizers/factor_neutral_optimization.py

@@ -0,0 +1,64 @@
+import tensorflow as tf
+import cvxpy as cp
+import numpy as np
+
+class FactorNeutralOptimizer(tf.keras.layers.Layer):
+    def __init__(self, n_assets, n_factors, factor_exposure_bounds=(-0.1, 0.1)):
+        super(FactorNeutralOptimizer, self).__init__()
+        self.n_assets = n_assets
+        self.n_factors = n_factors
+        self.factor_exposure_bounds = factor_exposure_bounds
+
+    def call(self, inputs):
+        mu, Sigma, factor_exposures = inputs
+        
+        def solve_factor_neutral_qp(mu, Sigma, factor_exposures):
+            w = cp.Variable(self.n_assets)
+            risk_aversion = cp.Parameter(nonneg=True)
+            
+            objective = mu @ w - risk_aversion * cp.quad_form(w, Sigma)
+            constraints = [
+                cp.sum(w) == 1,
+                w >= 0,
+                factor_exposures @ w >= self.factor_exposure_bounds[0],
+                factor_exposures @ w <= self.factor_exposure_bounds[1]
+            ]
+            
+            prob = cp.Problem(cp.Maximize(objective), constraints)
+            risk_aversion.value = 1.0  # Initial value for risk aversion
+            
+            try:
+                prob.solve(solver=cp.SCS)
+                if prob.status != cp.OPTIMAL:
+                    raise ValueError('Optimization problem not solved optimally')
+                return w.value
+            except:
+                # Fallback to equal-weight portfolio if optimization fails
+                return np.ones(self.n_assets) / self.n_assets
+
+        optimized_w = tf.py_function(
+            func=solve_factor_neutral_qp,
+            inp=[mu, Sigma, factor_exposures],
+            Tout=tf.float32
+        )
+        
+        return optimized_w
+
+class FactorNeutralDiffOptPortfolio(tf.keras.Model):
+    def __init__(self, input_dim, n_assets, n_factors, hidden_dim, factor_exposure_bounds=(-0.1, 0.1)):
+        super(FactorNeutralDiffOptPortfolio, self).__init__()
+        self.feature_extractor = tf.keras.Sequential([
+            tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(input_dim,)),
+            tf.keras.layers.Dense(hidden_dim, activation='relu')
+        ])
+        self.mu_predictor = tf.keras.layers.Dense(n_assets)
+        self.sigma_predictor = tf.keras.layers.Dense(n_assets * n_assets)
+        self.factor_exposures_predictor = tf.keras.layers.Dense(n_assets * n_factors)
+        self.factor_neutral_optimizer = FactorNeutralOptimizer(n_assets, n_factors, factor_exposure_bounds)
+    
+    def call(self, inputs):
+        features = self.feature_extractor(inputs)
+        mu = self.mu_predictor(features)
+        sigma = tf.reshape(self.sigma_predictor(features), (-1, mu.shape[1], mu.shape[1]))
+        factor_exposures = tf.reshape(self.factor_exposures_predictor(features), (-1, mu.shape[1], self.n_factors))
+        return self.factor_neutral_optimizer([mu, sigma, factor_exposures])

deepfolio/optimizers/hierarchical_risk_parity.py

@@ -0,0 +1,68 @@
+import tensorflow as tf
+import numpy as np
+import scipy.cluster.hierarchy as sch
+
+class HierarchicalRiskParityOptimizer(tf.keras.layers.Layer):
+    def __init__(self, n_assets):
+        super(HierarchicalRiskParityOptimizer, self).__init__()
+        self.n_assets = n_assets
+
+    def call(self, inputs):
+        returns, = inputs
+        
+        def hrp_optimization(returns):
+            # Calculate correlation matrix
+            corr = np.corrcoef(returns.T)
+            
+            # Distance matrix
+            dist = np.sqrt(0.5 * (1 - corr))
+            
+            # Hierarchical clustering
+            link = sch.linkage(dist, 'single')
+            sortIx = sch.leaves_list(link)
+            
+            # Sort correlation matrix
+            corr = corr[sortIx, :][:, sortIx]
+            
+            # Recursive bisection
+            weights = np.ones(self.n_assets)
+            clusters = [list(range(self.n_assets))]
+            while len(clusters) > 0:
+                clusters = [cl[start:end] for cl in clusters
+                            for start, end in ((0, len(cl) // 2), (len(cl) // 2, len(cl)))
+                            if len(cl) > 1]
+                for i in range(0, len(clusters), 2):
+                    cl1 = clusters[i]
+                    cl2 = clusters[i + 1]
+                    var1 = np.sum(np.var(returns[:, cl1], axis=0))
+                    var2 = np.sum(np.var(returns[:, cl2], axis=0))
+                    alpha = 1 - var1 / (var1 + var2)
+                    weights[cl1] *= alpha
+                    weights[cl2] *= 1 - alpha
+            
+            # Revert to original order
+            weights = weights[np.argsort(sortIx)]
+            return weights / np.sum(weights)
+
+        optimized_w = tf.py_function(
+            func=hrp_optimization,
+            inp=[returns],
+            Tout=tf.float32
+        )
+        
+        return optimized_w
+
+class HRPDiffOptPortfolio(tf.keras.Model):
+    def __init__(self, input_dim, n_assets, hidden_dim):
+        super(HRPDiffOptPortfolio, self).__init__()
+        self.feature_extractor = tf.keras.Sequential([
+            tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(input_dim,)),
+            tf.keras.layers.Dense(hidden_dim, activation='relu')
+        ])
+        self.returns_predictor = tf.keras.layers.Dense(n_assets)
+        self.hrp_optimizer = HierarchicalRiskParityOptimizer(n_assets)
+    
+    def call(self, inputs):
+        features = self.feature_extractor(inputs)
+        returns = self.returns_predictor(features)
+        return self.hrp_optimizer([returns])

deepfolio/optimizers/rl_dynamic_allocation.py

@@ -0,0 +1,103 @@
+import tensorflow as tf
+import numpy as np
+
+class MarketEnvironment:
+    def __init__(self, returns, initial_balance=10000, transaction_cost=0.001):
+        self.returns = returns
+        self.initial_balance = initial_balance
+        self.transaction_cost = transaction_cost
+        self.reset()
+    
+    def reset(self):
+        self.balance = self.initial_balance
+        self.position = np.zeros(self.returns.shape[1])
+        self.time = 0
+        return self._get_state()
+    
+    def step(self, action):
+        old_position = self.position
+        self.position = action
+        
+        # Apply transaction costs
+        self.balance -= np.sum(np.abs(self.position - old_position)) * self.balance * self.transaction_cost
+        
+        # Apply market returns
+        self.balance *= 1 + np.sum(self.position * self.returns[self.time])
+        
+        self.time += 1
+        done = self.time >= len(self.returns)
+        
+        return self._get_state(), self._get_reward(), done
+    
+    def _get_state(self):
+        return np.concatenate([
+            self.position,
+            [self.balance],
+            self.returns[self.time] if self.time < len(self.returns) else np.zeros_like(self.returns[0])
+        ])
+    
+    def _get_reward(self):
+        return np.log(self.balance / self.initial_balance)
+
+class Actor(tf.keras.Model):
+    def __init__(self, state_dim, action_dim):
+        super(Actor, self).__init__()
+        self.model = tf.keras.Sequential([
+            tf.keras.layers.Dense(64, activation='relu', input_shape=(state_dim,)),
+            tf.keras.layers.Dense(64, activation='relu'),
+            tf.keras.layers.Dense(action_dim, activation='softmax')
+        ])
+    
+    def call(self, state):
+        return self.model(state)
+
+class Critic(tf.keras.Model):
+    def __init__(self, state_dim):
+        super(Critic, self).__init__()
+        self.model = tf.keras.Sequential([
+            tf.keras.layers.Dense(64, activation='relu', input_shape=(state_dim,)),
+            tf.keras.layers.Dense(64, activation='relu'),
+            tf.keras.layers.Dense(1)
+        ])
+    
+    def call(self, state):
+        return self.model(state)
+
+class RLDynamicAllocation(tf.keras.Model):
+    def __init__(self, state_dim, action_dim, lr_actor=0.0001, lr_critic=0.001):
+        super(RLDynamicAllocation, self).__init__()
+        self.actor = Actor(state_dim, action_dim)
+        self.critic = Critic(state_dim)
+        self.actor_optimizer = tf.keras.optimizers.Adam(lr_actor)
+        self.critic_optimizer = tf.keras.optimizers.Adam(lr_critic)
+    
+    def train(self, env, episodes=1000):
+        for episode in range(episodes):
+            state = env.reset()
+            done = False
+            while not done:
+                with tf.GradientTape() as tape_actor, tf.GradientTape() as tape_critic:
+                    action_probs = self.actor(tf.convert_to_tensor([state], dtype=tf.float32))
+                    action = tf.random.categorical(tf.math.log(action_probs), 1)[0, 0]
+                    action_onehot = tf.one_hot(action, env.action_space.n)
+                    
+                    next_state, reward, done = env.step(action_onehot.numpy())
+                    
+                    critic_value = self.critic(tf.convert_to_tensor([state], dtype=tf.float32))
+                    next_critic_value = self.critic(tf.convert_to_tensor([next_state], dtype=tf.float32))
+                    
+                    advantage = reward + 0.99 * next_critic_value * (1 - done) - critic_value
+                    actor_loss = -tf.math.log(action_probs[0, action]) * advantage
+                    critic_loss = advantage ** 2
+                
+                actor_grads = tape_actor.gradient(actor_loss, self.actor.trainable_variables)
+                critic_grads = tape_critic.gradient(critic_loss, self.critic.trainable_variables)
+                
+                self.actor_optimizer.apply_gradients(zip(actor_grads, self.actor.trainable_variables))
+                self.critic_optimizer.apply_gradients(zip(critic_grads, self.critic.trainable_variables))
+                
+                state = next_state
+    
+    def get_action(self, state):
+        action_probs = self.actor(tf.convert_to_tensor([state], dtype=tf.float32))
+        return action_probs.numpy()[0]