Merge pull request #11 from AidinHamedi/dev

V1.8

Author: AidinHamedi

README.md

@@ -25,13 +25,13 @@ The optimizers are evaluated on the following standard 2D test functions. Click
 | Function                                                                                   | Function                                                                                             |
 | :----------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------- |
 | [Ackley](https://www.sfu.ca/~ssurjano/ackley.html)                                         | [Lévy N. 13](https://www.sfu.ca/~ssurjano/levy13.html)                                               |
-| [Drop-Wave](https://www.sfu.ca/~ssurjano/drop.html)                                        | [Eggholder](https://www.sfu.ca/~ssurjano/egg.html)                                                   |
+| [Langermann](https://www.sfu.ca/~ssurjano/langer.html)                                     | [Eggholder](https://www.sfu.ca/~ssurjano/egg.html)                                                   |
 | [Gramacy & Lee](https://www.sfu.ca/~ssurjano/grlee12.html)                                 | [Griewank](https://www.sfu.ca/~ssurjano/griewank.html)                                               |
-| [Michalewicz](https://www.sfu.ca/~ssurjano/michal.html)                                    | [Langermann](https://www.sfu.ca/~ssurjano/langer.html)                                               |
 | [Rastrigin](https://www.sfu.ca/~ssurjano/rastr.html)                                       | [Rosenbrock](https://www.sfu.ca/~ssurjano/rosen.html)                                                |
 | [Weierstrass](https://en.wikipedia.org/wiki/Weierstrass_function)                          | [Styblinski–Tang](https://www.sfu.ca/~ssurjano/stybtang.html)                                        |
 | [Goldstein-Price](https://www.sfu.ca/~ssurjano/goldpr.html)                                | [Gradient Labyrinth](https://aidinhamedi.github.io/Optimizer-Benchmark/functions/gradient_labyrinth) |
 | [Neural Canyon](https://aidinhamedi.github.io/Optimizer-Benchmark/functions/neural_canyon) | [Quantum Well](https://aidinhamedi.github.io/Optimizer-Benchmark/functions/quantum_well)             |
+| [Beale](https://www.sfu.ca/~ssurjano/beale.html)                                           |                                                                                        
 
 
 ## 📊 Results & Visualizations

benchmark/criterion.py

@@ -21,6 +21,7 @@ class ObjectiveConfig:
         terrain_violation_weight: Weight for terrain violations.
         convergence_tol: Normalized distance threshold for convergence.
         boundary_tol: Normalized distance for boundary violation.
+        efficiency_threshold: Minimum efficiency threshold for path efficiency.
         terrain_violation_tol: Normalized distance threshold to check for terrain violation.
         terrain_violation_accuracy: Number of points to check for terrain violation.
         lucky_jump_threshold: Maximum allowed step size (fraction of diagonal).
@@ -32,14 +33,15 @@ class ObjectiveConfig:
     final_val_weight: float = 1.8
     final_dist_weight: float = 2.6
     convergence_weight: float = 0.1
-    efficiency_weight: float = 0.1
+    efficiency_weight: float = 0.8
     lucky_jump_weight: float = 10.0
     start_prox_weight: float = 200.0
     boundary_weight: float = 16.0
     terrain_violation_weight: float = 20.0
 
     convergence_tol: float = 0.01
     boundary_tol: float = 0.08
+    efficiency_threshold: float = 1.4
     terrain_violation_tol: float = 0.01
     terrain_violation_accuracy: int = 7
     lucky_jump_threshold: float = 0.04
@@ -71,26 +73,34 @@ def _calc_boundary_violation(
 
 
 def _calc_path_inefficiency(
-    steps: torch.Tensor, step_lengths: torch.Tensor
+    steps: torch.Tensor,
+    step_lengths: torch.Tensor,
+    threshold: float,
 ) -> torch.Tensor:
-    """Compute path inefficiency as (total length / displacement) - 1."""
-    path_len = torch.sum(step_lengths)
-    displacement = torch.norm(steps[:, -1] - steps[:, 0])
-
-    if displacement < 1e-6:
-        return torch.tensor(0.0)
+    """Calculates path inefficiency by comparing the spatial footprint against significant movement effort."""
+    # Footprint: The diagonal of the bounding box touched by the optimizer
+    bbox_max = torch.max(steps, dim=1).values
+    bbox_min = torch.min(steps, dim=1).values
+    span = torch.norm(bbox_max - bbox_min)
 
-    return torch.relu((path_len / displacement) - 1.0)
+    # Jitter Filter: Ignore steps that are mathematically insignificant
+    # relative to the optimizer's largest movement (active phase).
+    max_s = torch.max(step_lengths)
+    active_mask = step_lengths > (max_s * 0.01)  # Ignore steps < 1% of peak velocity
+    significant_effort = torch.sum(step_lengths[active_mask])
 
+    # Raw Efficiency: Ratio of ground covered to significant energy spent.
+    # threshold acts as a 'Curvature Buffer' (e.g., 1.5 allows a path 50% longer than a straight line).
+    raw_efficiency = (span * threshold) / (significant_effort + 1e-12)
 
-def _calc_lucky_jump(step_lengths: torch.Tensor, threshold: float) -> torch.Tensor:
-    """Compute penalty for steps exceeding the threshold."""
-    max_step = torch.max(step_lengths)
+    return 1.0 - torch.clamp(raw_efficiency, max=1.0)
 
-    if max_step > threshold:
-        return (max_step - threshold) ** 2
 
-    return torch.tensor(0.0)
+def _calc_lucky_jump(step_lengths: torch.Tensor, threshold: float) -> torch.Tensor:
+    """Compute cumulative penalty for steps exceeding the threshold."""
+    excess = step_lengths - threshold
+    penalty = torch.clamp(excess, min=0.0)
+    return torch.sum(penalty**2)
 
 
 def _calc_start_proximity(
@@ -275,8 +285,12 @@ def objective(
 
     # Path inefficiency
     if config.efficiency_weight > 0:
-        inefficiency = _calc_path_inefficiency(steps, step_lengths).item()
-        eff_penalty = min(inefficiency, 10.0) * config.efficiency_weight
+        inefficiency = _calc_path_inefficiency(
+            steps,
+            step_lengths,
+            config.efficiency_threshold,
+        ).item()
+        eff_penalty = inefficiency * config.efficiency_weight
         metrics["eff_penalty"] = eff_penalty
         error_sum += eff_penalty
 

benchmark/functions/beale.py

@@ -0,0 +1,32 @@
+import torch
+
+from .norm import normalize
+
+FUNCTION_NAME = "Beale"
+START_POS = torch.tensor([1.0, 1.0])
+EVAL_SIZE = ((-4.5, 4.5), (-4.5, 4.5))
+CRITERION_OVERRIDES = {"val_scaler_root": 5}
+GLOBAL_MINIMUM_LOC = torch.tensor([[3.0, 0.5]])
+
+
+@normalize(4.929331043967977e-05, 383574.0625)
+@torch.jit.script
+def beale(
+    x: torch.Tensor,
+) -> torch.Tensor:
+    """Compute the Beale function.
+
+    Args:
+        x: Input tensor of shape [2] representing [x, y] coordinates.
+
+    Returns:
+        Scalar tensor with the function value.
+    """
+    x0 = x[..., 0]
+    x1 = x[..., 1]
+
+    term1 = 1.5 - x0 + x0 * x1
+    term2 = 2.25 - x0 + x0 * x1**2
+    term3 = 2.625 - x0 + x0 * x1**3
+
+    return term1**2 + term2**2 + term3**2

benchmark/functions/drop_wave.py

@@ -3,7 +3,7 @@
 from .norm import normalize
 
 FUNCTION_NAME = "NeuralCanyon"
-START_POS = torch.tensor([-4.5, 3.5])
+START_POS = torch.tensor([-6.5, 1.0])
 EVAL_SIZE = ((-8, 8), (-8, 8))
 CRITERION_OVERRIDES = {"val_scaler_root": 5}
 GLOBAL_MINIMUM_LOC = torch.tensor([[0.0, 0.0]])