chore: fix formatting issues to satisfy CI

Author: MichalRedm

scripts/check_ldc_bias.py

@@ -8,59 +8,63 @@
 
 from src.portfolio.moead import MOEADOptimizer
 
+
 def map_to_2d(weights):
     w2 = weights[:, 1]
     w3 = weights[:, 2]
     x = w2 + 0.5 * w3
     y = (np.sqrt(3.0) / 2.0) * w3
     return x, y
 
+
 def verify_ldc():
-    np.random.seed(1337) # Different seed
-    N_points = 5000      # More points
-    N_iterations = 200   # More iterations
+    np.random.seed(1337)  # Different seed
+    N_points = 5000  # More points
+    N_iterations = 200  # More iterations
     optimizer = MOEADOptimizer(problem=None)
-    
+
     # Start with uniform Dirichlet
     points = np.random.dirichlet(np.ones(3), N_points)
-    
+
     # Evolution loop for LDC
     for _ in range(N_iterations):
         indices = np.random.permutation(len(points))
         p1_idx = indices[: len(points) // 2]
         p2_idx = indices[len(points) // 2 :]
-        
+
         new_points = np.empty_like(points)
         for j in range(len(p1_idx)):
             p1 = points[p1_idx[j]]
             p2 = points[p2_idx[j]]
             c1 = optimizer._ldc_crossover(p1, p2)
             c2 = optimizer._ldc_crossover(p1, p2)
-            new_points[2*j] = c1
-            new_points[2*j+1] = c2
+            new_points[2 * j] = c1
+            new_points[2 * j + 1] = c2
         points = new_points
 
     # Plotting
     fig, ax = plt.subplots(figsize=(10, 8))
     h = np.sqrt(3) / 2
     ax.plot([0, 1, 0.5, 0], [0, 0, h, 0], "k-")
-    
+
     x, y = map_to_2d(points)
     hb = ax.hexbin(x, y, gridsize=40, cmap="magma", mincnt=0, extent=(0, 1, 0, h))
-    
+
     # Clipping
     from matplotlib.patches import Polygon
+
     vertices = np.array([[0, 0], [1, 0], [0.5, h]])
     clip_poly = Polygon(vertices, transform=ax.transData)
     hb.set_clip_path(clip_poly)
-    
+
     plt.title("High-Fidelity LDC Verification (N=5000, Iter=200)")
     plt.colorbar(hb)
-    
+
     output_path = "artifacts/ldc_high_fidelity.png"
     os.makedirs("artifacts", exist_ok=True)
     plt.savefig(output_path)
     print(f"Plot saved to {output_path}")
 
+
 if __name__ == "__main__":
     verify_ldc()

scripts/experiment_evolution.py

@@ -44,7 +44,9 @@ def run_evolution_demo():
     run_folder = os.path.join(OUTPUT_FOLDER, run_id)
     os.makedirs(run_folder, exist_ok=True)
 
-    print(f"Starting Multi-Variant Evolution Demo. Results will be saved to {run_folder}")
+    print(
+        f"Starting Multi-Variant Evolution Demo. Results will be saved to {run_folder}"
+    )
 
     # 1. Load data and calculate expected returns/cov
     raw_data_dict = load_data(DATA_FOLDER, ASSET_NAMES, verbose=False)

scripts/experiment_operator_bias.py

@@ -8,6 +8,7 @@
 
 from src.portfolio.moead import MOEADOptimizer
 
+
 def map_to_2d(weights):
     """Maps 3-simplex weights to 2D for triangular plotting."""
     w2 = weights[:, 1]
@@ -16,6 +17,7 @@ def map_to_2d(weights):
     y = (np.sqrt(3.0) / 2.0) * w3
     return x, y
 
+
 def plot_triangle(ax):
     """Plots the boundary of the 3-simplex and returns its vertices."""
     h = np.sqrt(3) / 2
@@ -26,48 +28,46 @@ def plot_triangle(ax):
     ax.axis("off")
     return vertices
 
+
 def run_simulation():
     np.random.seed(42)
-    N_points = 2000 
+    N_points = 2000
     N_iterations = 100
     N_runs = 5
     h = np.sqrt(3) / 2
-    
+
     optimizer = MOEADOptimizer(problem=None)
-    
+
     combinations = [
         # (Crossover, Mutation, Repair, Title)
         ("sbx", "none", "simple", "SBX + Simple Norm"),
         ("none", "polynomial", "simple", "PolyMut + Simple Norm"),
         ("sbx", "polynomial", "simple", "SBX + PolyMut + Simple Norm"),
-        
         ("sbx", "none", "euclidean", "SBX + Euclidean"),
         ("none", "polynomial", "euclidean", "PolyMut + Euclidean"),
         ("sbx", "polynomial", "euclidean", "SBX + PolyMut + Euclidean"),
-        
         ("simplex", "none", "none", "Simplex Crossover Only"),
         ("none", "simplex", "none", "Simplex Mutation Only"),
         ("simplex", "simplex", "none", "Simplex Crossover + Mutation"),
-
         ("ldc", "none", "none", "LDC (Latent) Crossover Only"),
         ("none", "simplex", "none", "Simplex Mutation Only (Ref)"),
         ("ldc", "simplex", "none", "LDC Crossover + Mutation"),
     ]
-    
+
     fig, axes = plt.subplots(4, 3, figsize=(18, 24))
     axes = axes.flatten()
-    
+
     cmap = plt.cm.magma  # Dark background colormap
-    
+
     for idx, (cross, mut, repair_meth, title) in enumerate(combinations):
         print(f"Simulating: {title} ({N_runs} runs)...")
-        
+
         ensemble_points = []
-        
+
         for run_idx in range(N_runs):
             # 1. Start with a fresh uniform distribution per run
             points = np.random.dirichlet(np.ones(3), N_points)
-            
+
             def apply_repair(w):
                 if repair_meth == "euclidean":
                     return optimizer._repair(w)
@@ -79,13 +79,13 @@ def apply_repair(w):
                 indices = np.random.permutation(len(points))
                 p1_idx = indices[: len(points) // 2]
                 p2_idx = indices[len(points) // 2 :]
-                
+
                 new_points = np.empty_like(points)
-                
+
                 for j in range(len(p1_idx)):
                     p1 = points[p1_idx[j]]
                     p2 = points[p2_idx[j]]
-                    
+
                     if cross == "sbx":
                         c1 = optimizer._sbx_crossover(p1, p2)
                         c2 = optimizer._sbx_crossover(p1, p2)
@@ -99,7 +99,7 @@ def apply_repair(w):
                         c2 = optimizer._ldc_crossover(p1, p2)
                     else:
                         c1, c2 = p1.copy(), p2.copy()
-                    
+
                     if mut == "polynomial":
                         c1 = optimizer._polynomial_mutation(c1)
                         c2 = optimizer._polynomial_mutation(c2)
@@ -108,48 +108,44 @@ def apply_repair(w):
                     elif mut == "simplex":
                         c1 = optimizer._simplex_mutation(c1, eta=0.1)
                         c2 = optimizer._simplex_mutation(c2, eta=0.1)
-                    
-                    new_points[2*j] = c1
-                    new_points[2*j+1] = c2
-                
+
+                    new_points[2 * j] = c1
+                    new_points[2 * j + 1] = c2
+
                 points = new_points
-            
+
             ensemble_points.append(points)
-        
+
         aggregate_points = np.vstack(ensemble_points)
-        
+
         # Plotting
         ax = axes[idx]
-        
+
         # Clip to the triangle specifically
         vertices = plot_triangle(ax)
         x, y = map_to_2d(aggregate_points)
-        
+
         # Use mincnt=0 to draw ALL hexagons in the extent, then clip to triangle
-        hb = ax.hexbin(
-            x, y, 
-            gridsize=30, 
-            cmap=cmap, 
-            mincnt=0,
-            extent=(0, 1, 0, h)
-        )
-        
+        hb = ax.hexbin(x, y, gridsize=30, cmap=cmap, mincnt=0, extent=(0, 1, 0, h))
+
         # Clipping: create a polygon path from vertices
         from matplotlib.patches import Polygon
+
         clip_poly = Polygon(vertices, transform=ax.transData)
         hb.set_clip_path(clip_poly)
-        
+
         # Add colorbar (legend) per subplot
         cb = fig.colorbar(hb, ax=ax, shrink=0.6, pad=0.05)
         cb.set_label("Solution Count", fontsize=8)
-        
+
         ax.set_title(title, fontsize=12, fontweight="bold")
-        
+
     plt.tight_layout()
     output_path = os.path.join("plots", "operator_bias_comparison.png")
     os.makedirs("plots", exist_ok=True)
     plt.savefig(output_path, dpi=150, bbox_inches="tight")
     print(f"\nResult saved to {output_path}")
 
+
 if __name__ == "__main__":
     run_simulation()

scripts/find_optimal_beta.py

@@ -1,41 +1,44 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
+
 def simplex_crossover(p1, p2, beta_val):
     diff = p1 - p2
     pos_mask = diff > 1e-9
     neg_mask = diff < -1e-9
-    
+
     alpha_min = np.max(-p2[pos_mask] / diff[pos_mask]) if np.any(pos_mask) else 0.0
     alpha_max = np.min(-p2[neg_mask] / diff[neg_mask]) if np.any(neg_mask) else 1.0
-    
+
     u = np.random.beta(beta_val, beta_val)
     alpha = alpha_min + u * (alpha_max - alpha_min)
-    
+
     offspring = alpha * p1 + (1.0 - alpha) * p2
     return offspring / np.sum(offspring)
 
+
 def check_uniformity(points, D):
     # For a uniform distribution on the simplex, each weight w_i ~ Beta(1, D-1)
     # The mean is 1/D, variance is (D-1)/(D^2 * (D+1))
     # We can check the empirical CDF against the theoretical Beta(1, D-1)
-    w = points[:, 0] # Check first dimension
+    w = points[:, 0]  # Check first dimension
     w_sorted = np.sort(w)
     n = len(w)
-    emp_cdf = np.arange(1, n+1) / n
-    theo_cdf = 1 - (1 - w_sorted)**(D-1) # CDF of Beta(1, D-1)
-    
+    emp_cdf = np.arange(1, n + 1) / n
+    theo_cdf = 1 - (1 - w_sorted) ** (D - 1)  # CDF of Beta(1, D-1)
+
     # Kolmogorov-Smirnov-like statistic
     return np.max(np.abs(emp_cdf - theo_cdf))
 
+
 def run_parameter_search():
     Ds = [2, 3, 4, 10]
     betas = np.linspace(0.4, 1.0, 7)
     n_points = 2000
     iterations = 100
-    
+
     results = {}
-    
+
     for D in Ds:
         print(f"Testing D={D}...")
         results[D] = []
@@ -45,18 +48,18 @@ def run_parameter_search():
             for _ in range(iterations):
                 idx = np.random.permutation(n_points)
                 for i in range(0, n_points, 2):
-                    p1, p2 = points[idx[i]], points[idx[i+1]]
+                    p1, p2 = points[idx[i]], points[idx[i + 1]]
                     points[idx[i]] = simplex_crossover(p1, p2, b)
-                    points[idx[i+1]] = simplex_crossover(p1, p2, b)
-            
+                    points[idx[i + 1]] = simplex_crossover(p1, p2, b)
+
             error = check_uniformity(points, D)
             results[D].append(error)
             print(f"  beta={b:.2f}, error={error:.4f}")
 
     # Plot
     plt.figure(figsize=(10, 6))
     for D in Ds:
-        plt.plot(betas, results[D], 'o-', label=f"D={D}")
+        plt.plot(betas, results[D], "o-", label=f"D={D}")
     plt.xlabel("Beta parameter")
     plt.ylabel("K-S Error (lower is better)")
     plt.title("Search for Optimal Beta to Preserve Uniformity")
@@ -65,5 +68,6 @@ def run_parameter_search():
     plt.savefig("scripts/optimal_beta_search.png")
     print("Optimization results saved to scripts/optimal_beta_search.png")
 
+
 if __name__ == "__main__":
     run_parameter_search()