feat(awa): improve adaptive weight adjustment and evaluation metrics

Author: MichalRedm

scripts/experiment_awa.py

@@ -34,7 +34,7 @@
     RiskObjective,
     DiversificationObjective,
 )
-from src.portfolio.metrics import calculate_igd, calculate_spacing
+from src.portfolio.metrics import calculate_igd, calculate_spacing, calculate_spread
 
 
 def run_awa_experiment():
@@ -75,8 +75,8 @@ def run_awa_experiment():
     )
     ref_front = np.column_stack([ref_metrics["Return"], ref_metrics["Risk"]])
 
-    # ── Experiment 1: Distribution Uniformity (Spacing) ──────────────────────
-    print("Running Experiment 1: Distribution Uniformity...")
+    # ── Experiment 1 & 3 Combined: Distribution and Quality Comparison ──────
+    print("Running Quality Comparison (IGD, Spacing, Spread)...")
     pop_size = NUM_PARETO_POINTS
     gens = MOEAD_GENERATIONS
 
@@ -91,7 +91,12 @@ def run_awa_experiment():
         **data_kwargs,
     )
     front1 = np.column_stack([metrics1["Return"], metrics1["Risk"]])
-    spacing1 = calculate_spacing(front1)
+
+    m_dict1 = {
+        "IGD": calculate_igd(front1, ref_front),
+        "Spacing": calculate_spacing(front1),
+        "Spread": calculate_spread(front1, ref_front),
+    }
 
     # MOEA/D-AWA
     print("  Evaluating MOEA/D-AWA...")
@@ -105,33 +110,33 @@ def run_awa_experiment():
         **data_kwargs,
     )
     front2 = np.column_stack([metrics2["Return"], metrics2["Risk"]])
-    spacing2 = calculate_spacing(front2)
 
-    print(f"  Spacing - MOEA/D: {spacing1:.6f}")
-    print(f"  Spacing - MOEA/D-AWA: {spacing2:.6f}")
+    m_dict2 = {
+        "IGD": calculate_igd(front2, ref_front),
+        "Spacing": calculate_spacing(front2),
+        "Spread": calculate_spread(front2, ref_front),
+    }
 
-    # Plot Comparison
-    plt.figure(figsize=(10, 6))
-    plt.scatter(
-        front1[:, 1],
-        front1[:, 0],
-        label=f"Standard MOEA/D (Spacing: {spacing1:.6f})",
-        alpha=0.6,
+    print(
+        f"  MOEA/D     - IGD: {m_dict1['IGD']:.6f}, Spacing: {m_dict1['Spacing']:.6f}, Spread: {m_dict1['Spread']:.6f}"
     )
-    plt.scatter(
-        front2[:, 1],
-        front2[:, 0],
-        label=f"MOEA/D-AWA (Spacing: {spacing2:.6f})",
-        alpha=0.6,
+    print(
+        f"  MOEA/D-AWA - IGD: {m_dict2['IGD']:.6f}, Spacing: {m_dict2['Spacing']:.6f}, Spread: {m_dict2['Spread']:.6f}"
     )
-    plt.xlabel("Risk (Standard Deviation)")
-    plt.ylabel("Return")
-    plt.title("Experiment 1: Pareto Front Distribution Quality")
-    plt.legend()
-    plt.grid(True)
-    plt.savefig(os.path.join(run_folder, "exp1_uniformity.png"))
-    plt.close()
 
+    # Plot Comparison (Consolidated)
+    from src.visualization import plot_two_variants_comparison_2d
+
+    plot_two_variants_comparison_2d(
+        ref_metrics,
+        metrics1,
+        metrics2,
+        name1="Standard MOEA/D",
+        name2="MOEA/D-AWA",
+        metrics_dict1=m_dict1,
+        metrics_dict2=m_dict2,
+        save_path=os.path.join(run_folder, "awa_comparison_2d.png"),
+    )
     # ── Experiment 2: Performance vs Generations (Adaptive Progress) ──────────
     print("Running Experiment 2: Convergence Progress...")
     # Compare IGD history
@@ -160,29 +165,16 @@ def run_awa_experiment():
     gens_list = np.arange(0, gens + 1, 20)
 
     plt.figure(figsize=(10, 6))
-    plt.plot(gens_list, igd1, "o-", label="Standard MOEA/D")
-    plt.plot(gens_list, igd2, "s-", label="MOEA/D-AWA")
+    plt.plot(gens_list, igd1, "o-", label="Standard MOEA/D", color="#1f77b4")
+    plt.plot(gens_list, igd2, "s-", label="MOEA/D-AWA", color="#ff7f0e")
     plt.xlabel("Generations")
     plt.ylabel("IGD")
-    plt.title("Experiment 2: Convergence Progress with Weight Adaptation")
+    plt.title("Convergence Progress with Weight Adaptation", fontsize=14)
     plt.legend()
-    plt.grid(True)
-    plt.savefig(os.path.join(run_folder, "exp2_convergence.png"))
+    plt.grid(True, linestyle="--", alpha=0.6)
+    plt.savefig(os.path.join(run_folder, "awa_convergence_progress.png"), dpi=150)
     plt.close()
 
-    # ── Experiment 3: 2D Pareto Comparison ──────────────────────────────────
-    print("Running Experiment 3: 2D Pareto Comparison...")
-    from src.visualization import plot_two_variants_comparison_2d
-
-    plot_two_variants_comparison_2d(
-        ref_metrics,
-        metrics1,
-        metrics2,
-        name1="Standard MOEA/D",
-        name2="MOEA/D-AWA",
-        save_path=os.path.join(run_folder, "exp3_2d_comparison.png"),
-    )
-
     # ── Experiment 4: 3D Pareto Comparison ──────────────────────────────────
     print("Running Experiment 4: 3D Pareto Comparison...")
     prob_3d = PortfolioProblem(

src/portfolio/metrics.py

@@ -111,17 +111,25 @@ def calculate_spacing(obtained_front):
     Measures the uniformity of the distribution of solutions in the obtained front.
     Lower is better (0 means perfectly uniform).
 
+    This implementation normalizes the front to [0, 1] internally to ensure
+    scale independence between different objectives.
+
     S = sqrt(1/(n-1) * sum((d_i - d_mean)^2))
     where d_i is the distance to the nearest neighbor.
     """
     if len(obtained_front) < 2:
         return 0.0
 
-    # Calculate pairwise distances
-    n = len(obtained_front)
-    dists = np.sqrt(
-        np.sum((obtained_front[:, None] - obtained_front[None, :]) ** 2, axis=2)
-    )
+    # 1. Normalization
+    z_min = np.min(obtained_front, axis=0)
+    z_max = np.max(obtained_front, axis=0)
+    span = z_max - z_min
+    span[span < 1e-10] = 1e-10
+    front_norm = (obtained_front - z_min) / span
+
+    # 2. Calculate pairwise distances
+    n = len(front_norm)
+    dists = np.sqrt(np.sum((front_norm[:, None] - front_norm[None, :]) ** 2, axis=2))
 
     # Fill diagonal with infinity to ignore self-distance
     np.fill_diagonal(dists, np.inf)
@@ -132,3 +140,51 @@ def calculate_spacing(obtained_front):
 
     s = np.sqrt(np.sum((d - d_mean) ** 2) / (n - 1))
     return s
+
+
+def calculate_spread(obtained_front, reference_front):
+    """
+    Calculates the Spread (Delta) metric for 2D fronts.
+    Measures both the uniformity and the extent of the distribution.
+    Lower is better (0 means perfect uniformity and full coverage of extreme points).
+
+    reference_front: array of shape (N_ref, 2)
+    obtained_front: array of shape (N_obt, 2)
+    """
+    if len(obtained_front) < 2:
+        return 1.0
+
+    # 1. Normalization based on reference front bounds
+    z_min = np.min(reference_front, axis=0)
+    z_max = np.max(reference_front, axis=0)
+    span = z_max - z_min
+    span[span < 1e-10] = 1e-10
+
+    ref_norm = (reference_front - z_min) / span
+    obt_norm = (obtained_front - z_min) / span
+
+    # 2. Find extreme points in reference front (min risk, max return)
+    # Objective 0 (Return) max, Objective 1 (Risk) min
+    # In normalized space:
+    # Extreme 1: Max Return (1.0), likely high risk
+    # Extreme 2: Min Risk (0.0), likely low return
+    ext1_ref = ref_norm[np.argmax(ref_norm[:, 0])]
+    ext2_ref = ref_norm[np.argmin(ref_norm[:, 1])]
+
+    # 3. Sort obtained points by first objective for neighbor distances
+    idx = np.argsort(obt_norm[:, 0])
+    pts = obt_norm[idx]
+
+    # 4. Distances to extremes
+    df = np.sqrt(np.sum((pts[0] - ext1_ref) ** 2))
+    dl = np.sqrt(np.sum((pts[-1] - ext2_ref) ** 2))
+
+    # 5. Distances between consecutive points
+    d = np.sqrt(np.sum((pts[1:] - pts[:-1]) ** 2, axis=1))
+    d_mean = np.mean(d)
+
+    # 6. Delta calculation
+    sum_diff = np.sum(np.abs(d - d_mean))
+    delta = (df + dl + sum_diff) / (df + dl + (len(pts) - 1) * d_mean)
+
+    return delta

src/portfolio/moead_awa.py

@@ -175,35 +175,64 @@ def repair(w):
                 ep_f_norm = ep_f_norm[eff_idx]
 
                 if len(ep_f_norm) > num_points:
-                    # Identify sparse and dense regions for weight adjustment
-                    n_add = int(0.05 * num_points) + 1
+                    # Identify sparse regions in EP and dense regions in current population
+                    # We adjust a smaller percentage to ensure stability (3% instead of 5%)
+                    n_add = max(1, int(0.03 * num_points))
 
-                    # Sparsity in EP
+                    # 1. Sparsity in EP (Distance to 2nd nearest neighbor)
                     dists_ep = np.sqrt(
                         np.sum((ep_f_norm[:, None] - ep_f_norm[None, :]) ** 2, axis=2)
                     )
                     dists_ep.sort(axis=1)
+                    # Use a combination of nearest and 2nd nearest for robustness
                     sparsity = dists_ep[:, 1] + dists_ep[:, 2]
                     top_sparse_idx = np.argsort(sparsity)[-n_add:]
 
-                    # Density in current population
+                    # 2. Density in current population
                     dists_pop = np.sqrt(
                         np.sum((f_norm[:, None] - f_norm[None, :]) ** 2, axis=2)
                     )
                     dists_pop.sort(axis=1)
                     pop_density = 1.0 / (dists_pop[:, 1] + 1e-10)
-                    to_remove = np.argsort(pop_density)[-n_add:]
 
-                    for k, idx in enumerate(top_sparse_idx):
-                        f_sparse = ep_f_norm[idx] + 1e-10
-                        new_wv = (1.0 / f_sparse) / np.sum(1.0 / f_sparse)
+                    # Sort by density (highest first)
+                    potential_to_remove = np.argsort(pop_density)[::-1]
+
+                    # 3. Filter to_remove: Avoid removing extreme weight vectors
+                    # (those close to axis boundaries like [1, 0] or [0, 1])
+                    to_remove = []
+                    for idx in potential_to_remove:
+                        # Check if it's an extreme weight vector (any component > 0.9)
+                        if np.any(weight_vectors[idx] > 0.9):
+                            continue
+                        to_remove.append(idx)
+                        if len(to_remove) >= n_add:
+                            break
+
+                    # 4. Perform adjustment
+                    for k, sparse_idx in enumerate(top_sparse_idx):
+                        if k >= len(to_remove):
+                            break
+
+                        f_sparse = ep_f_norm[sparse_idx]
+
+                        # Generate new weight vector based on reference type
+                        if reference_type == "ideal":
+                            # Tchebycheff: lambda_i * f_i = const => lambda_i = 1/f_i
+                            new_wv = 1.0 / (f_sparse + 1e-6)
+                        else:
+                            # Nadir-based: (1 - f_i) / lambda_i = const => lambda_i = 1 - f_i
+                            new_wv = 1.0 - f_sparse + 1e-6
+
+                        new_wv /= np.sum(new_wv)
 
                         replace_idx = to_remove[k]
                         weight_vectors[replace_idx] = new_wv
-                        population[replace_idx] = ep_weights[idx]
-                        f_phys[replace_idx] = ep_f_phys[idx]
-                        f_norm[replace_idx] = ep_f_norm[idx]
+                        population[replace_idx] = ep_weights[sparse_idx]
+                        f_phys[replace_idx] = ep_f_phys[sparse_idx]
+                        f_norm[replace_idx] = ep_f_norm[sparse_idx]
 
+                    # Re-calculate neighbors for all subproblems after weight changes
                     neighbors = self._get_neighbors(weight_vectors, T)
 
             if kwargs.get("record_history", False):