analytics

aiOpt.py

@@ -0,0 +1,98 @@
+import random
+import numpy as np
+
+class Asset():
+  def __init__(self, cost, prob):
+    """Create a new state space with given dimensions."""
+    self.cost = cost
+    self.prob = prob
+    self.volume = []
+    print("cost: ", cost)
+    print("prob: ", prob)
+    print("Assume volume is bound by 0 to 100")
+    print("Objective: max SUM [ vol_s * prob_s - cost_s ]")
+
+  def hill_climb(self, maximum=None, log=False):
+    """Performs hill-climbing to find a solution."""
+    count = 0
+
+    self.volume=np.random.randint(0,100,len(self.prob))
+
+    if log:
+      print("Initial state: profit", self.get_profit(self.volume))
+
+    # Continue until we reach maximum number of iterations
+    while maximum is None or count < maximum:
+      count += 1
+      best_neighbors = []
+      best_neighbor_profit = None
+
+      for i,vol_s in enumerate(self.volume):
+
+        for replacement in self.get_neighbors(vol_s):
+          neighbor = self.volume.copy()
+          neighbor[i] = replacement
+
+          # Check if neighbor is best so far
+          profit = self.get_profit(neighbor)
+          if best_neighbor_profit is None or profit > best_neighbor_profit:
+            best_neighbor_profit = profit
+            best_neighbors = [neighbor]
+          elif best_neighbor_profit == profit:
+            best_neighbors.append(neighbor)
+
+      # None of the neighbors are better than the current state
+      if best_neighbor_profit <= self.get_profit(self.volume):
+        return self.volume
+
+      # Move to a highest-valued neighbor
+      else:
+        if log:
+          print(f"Found better neighbor: cost {best_neighbor_profit}")
+        self.volume = random.choice(best_neighbors)
+
+
+  def random_restart(self, maximum, image_prefix=None, log=False):
+    """Repeats hill-climbing multiple times."""
+    best_volume = None
+    best_profit = None
+
+    # Repeat hill-climbing a fixed number of times
+    for i in range(maximum):
+      volume = self.hill_climb()
+      profit = self.get_profit(volume)
+      if best_profit is None or profit > best_profit:
+        best_profit = profit
+        best_volume = volume
+        if log:
+          print(f"{i}: Found new best state: profit {profit} with volume {volume}")
+      else:
+        if log:
+          print(f"{i}: Found state: profit {profit}")
+
+    return best_volume
+
+  def get_profit(self, volume):
+    profit = 0
+    for i,vol_s in enumerate(self.volume):
+      profit += vol_s * self.prob[i] - self.cost[i]
+    return profit
+
+  def get_neighbors(self, vol_s):
+    candidates = [
+      vol_s-5, vol_s+5
+    ]
+    neighbors = []
+    for c in candidates:
+      if 0 <= c < 100:
+        neighbors.append(c)
+    return neighbors
+
+
+if __name__ == "__main__":
+
+  num_assets=10
+  s = Asset(np.random.randint(0, 10, num_assets),
+            np.random.rand(num_assets))
+
+  s.random_restart(10, log=True)

app.py

@@ -7,6 +7,16 @@ https://huggingface.co/spaces/kevinhug/clientX
 https://hits.seeyoufarm.com/
 '''
 
+'''
+PORTFOLIO OPTIMIZATION
+'''
+from .aiOpt import Asset
+import numpy as np
+def optimize(cost, prob, its):
+  s = Asset(np.asfarray(cost.split()),
+            np.asfarray(prob.split()))
+
+  return s.random_restart(int(its))
 '''
 TIME SERIES ANALYTICS
 '''
@@ -257,13 +267,14 @@ By identifying growth and decline industries, traders can make informed investme
   we can use this to filter out blacklisted firms for compliance
   
 - objective function can identify potential industry
+  
 
 #### Personalize UI to fit each trader
-here is my https://public.tableau.com/app/profile/kevin1619
-
-customize UI for secret sauce formula for stock picking:
-- metric: moving average for the price, moving average for volume, ...etc
-- timeframe chain: monthly, weekly, daily, 4h, 15 min
+  here is my https://public.tableau.com/app/profile/kevin1619
+  
+  customize UI for secret sauce formula for stock picking:
+  - metric: moving average for the price, moving average for volume, ...etc
+  - timeframe chain: monthly, weekly, daily, 4h, 15 min
 
 #### Personalize Alert with Twilio
 The trader can set their price to buy at the right price at the right time, without missing the right entry in a high stress environment
@@ -271,5 +282,52 @@ The trader can set their price to buy at the right price at the right time, with
 
     """)
 
+
+
+  with gr.Tab("Portfolio Optimization"):
+    in_p_cost = gr.Textbox(placeholder="4 30 2 3 5",
+                            label="Cost",
+                            info="cost for the asset"
+                            )
+    in_p_prob = gr.Textbox(placeholder="0.3 0.4 0.5 0.6 0.7",
+                            label="Probabilities",
+                            info="P(success) for the asset"
+                            )
+    in_p_its = gr.Textbox(placeholder="10",
+                            label="Number of Iteration",
+                            info="number of trial for optimal"
+                            )
+    out_p = gr.Textbox(label="Asset Allocation Approx Optimization using AI")
+
+    btn_p = gr.Button("Optimize Asset Allocation")
+    btn_p.click(fn=optimize, inputs=[in_p_cost, in_p_prob, in_p_its], outputs=out_p)
+
+    gr.Markdown("""
+Objective: To allocate assets in a way that maximizes expected profit while minimizing costs and risks.
+
+Inputs:
+- List of available assets and their associated probabilities and costs.
+
+Outputs:
+- Allocation of assets that maximizes expected profit while minimizing costs and risks.
+
+Constraints:
+Assume volume is bound by 0 to 100
+Objective: max SUM [ vol_s * prob_s - cost_s ]
+
+- The total cost of the allocation must not exceed the available budget.
+- The risk level of the allocation must not exceed the maximum allowable risk level.
+- The profit margin of the allocation must not fall below the minimum allowable profit margin.
+
+Method:
+Using search algorithm to find the approx. optimial allocation
+
+Assumptions:
+- The probabilities and costs of the assets are known with certainty.
+- The expected return and risk level of the allocation are calculated using historical data and statistical models.
+
+
+    """
+
 demo.launch()