Wroking version of basic fine-tuning

Author: Breta01

brain/api.py

@@ -23,19 +23,28 @@
 
 
 class BrainAPI:
-    """Class for BrainAPI session."""
+    """Class for communicating with BrainAPI session."""
+
+    _instance = None
 
     def __init__(self):
         self.s = requests.Session()
         self._authenticate()
 
+    def __new__(cls):
+        # Singleton pattern to ensure only one instance of BrainAPI exists.
+        if cls._instance is None:
+            cls._instance = super(BrainAPI, cls).__new__(cls)
+        return cls._instance
+
     def get_simulation_result_json(self, alpha_id):
         """Get result of simulation as JSON dictionary."""
         return self._request("GET", "/alphas/" + alpha_id).json()
 
     def start_simulation(self, simulate_data):
         """Start simulation of provided alpha."""
-        return self._request("POST", "/simulations", json=simulate_data)
+        self.check_session_timeout()
+        return self.s.post(f"{BRAIN_API_URL}/simulations", json=simulate_data)
 
     def check_session_timeout(self):
         """Check session time out and refresh session if necessary."""
@@ -334,6 +343,7 @@ def get_specified_alpha_stats(
                 .drop_duplicates(subset=["test"], keep="last")
                 .reset_index(drop=True)
             )
+
         if check_prod_corr and not check_submission:
             prod_corr_test = self.check_prod_corr_test(alpha_id)
             is_tests = (
@@ -527,7 +537,7 @@ def get_datafields(
         datafields_df = pd.DataFrame(datafields_list_flat)
         return datafields_df
 
-    def _request(self, method: str, endpoint: str, max_retries: int = 20, **kwargs):
+    def _request(self, method: str, endpoint: str, max_retries: int = 120, **kwargs):
         """Generic request method with retry logic."""
         while max_retries > 0:
             response = self.s.request(method, BRAIN_API_URL + endpoint, **kwargs)

brain/fine_tune.py

@@ -3,6 +3,7 @@
 from itertools import product
 
 from brain.alpha_helpers import generate_alpha
+from brain.api import BrainAPI
 
 
 def generate_alpha_grid(regular: str):
@@ -26,5 +27,24 @@ def generate_alpha_grid(regular: str):
     return alphas
 
 
-def fine_tune_alpha():
-    pass
+def get_fitness(result):
+    """Get the fitness of the alpha from result."""
+    stats = result["is_stats"]
+    if "fitness" in stats:
+        return stats["fitness"][0]
+
+    return -1
+
+
+def fine_tune_alpha(regular: str):
+    alphas = generate_alpha_grid(regular)
+    results = BrainAPI().simulate_alpha_list(alphas)
+    sorted_results = sorted(results, key=get_fitness, reverse=True)
+
+    print("Best alpha parameters:")
+    for i, result in enumerate(sorted_results):
+        print(f"Rank {i + 1}:")
+        print(f"Alpha: {result['alpha']}")
+        print(f"Fitness: {get_fitness(result)}")
+        print(f"Parameters: {result['simulate_data']}")
+        print()

brain/main.py

@@ -2,24 +2,12 @@
 
 from brain.alpha_helpers import generate_alpha
 from brain.api import BrainAPI
+from brain.fine_tune import fine_tune_alpha
 
 
 def main():
-    api = BrainAPI()
-
-    k = [
-        "vwap * 2",
-        "open * close",
-        "high * low",
-        "vwap * 3",
-        "open * close",
-        "high * low",
-    ]
-    alpha_list = [generate_alpha(x) for x in k]
-
-    results = api.simulate_alpha_list(alpha_list)
-    print("Simulation results:")
-    print(results)
+    alpha = "-ts_mean(snt_buzz_bfl, 2) * ts_zscore(snt_buzz, 20)"
+    fine_tune_alpha(alpha)
 
 
 if __name__ == "__main__":