evograd-diff 0.2.0__tar.gz → 0.3.0__tar.gz

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/.gitignore

@@ -2,6 +2,7 @@
 dist/
 build/
 *.egg-info/
+docs/_build/
 
 # Python caches
 __pycache__/

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evograd-diff
-Version: 0.2.0
+Version: 0.3.0
 Summary: PyTorch-based framework for differentiable evolutionary computation and swarm intelligence
 Project-URL: Homepage, https://github.com/andreatangherloni/EvoGrad
 Project-URL: Repository, https://github.com/andreatangherloni/EvoGrad
@@ -85,22 +85,26 @@ problem = Problem(
 
 # Run with Genetic Algorithm
 ga = GA(pop_size=100, differentiable=True)
-result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42,
+                  lr_pop=-1, lr_hyper=-1)
 print(f"GA Best: {result.best_fitness:.6f}")
 
 # Run with Differential Evolution
 de = DE(pop_size=100, variant="DE/rand/1/bin", adaptive=True)
-result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42,
+                  lr_hyper=-1)
 print(f"DE Best: {result.best_fitness:.6f}")
 
 # Run with Particle Swarm Optimisation
 pso = PSO(pop_size=100, adaptive=True, differentiable=True)
-result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42,
+                  lr_pop=-1, lr_hyper=-1)
 print(f"PSO Best: {result.best_fitness:.6f}")
 
 # Run with CMA-ES
 cmaes = CMAES(sigma=0.5, adaptive=True)
-result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42,
+                  lr_hyper=-1)
 print(f"CMA-ES Best: {result.best_fitness:.6f}")
 ```
 
@@ -140,6 +144,12 @@ ga = GA(
 | Operator `adaptive=True` | Operator uses Gumbel-Softmax/Binary-Concrete for gradient flow |
 | Operator `learn_*=True` | Operator hyperparameters become learnable `nn.Parameter` |
 
+Gradient optimizers are opt-in at the `minimize()` call. `lr_pop=None` and
+`lr_hyper=None` (the defaults) perform no backpropagation; use `-1` to select
+EvoGrad's algorithm-specific learning rate or pass a numeric value. For strict
+classical behavior, also construct the algorithm with `differentiable=False`
+and `adaptive=False`.
+
 ### Differential Evolution (DE)
 
 DE uses **algorithm-level flags** for adaptive hyperparameters and differentiable population:
@@ -453,6 +463,9 @@ The **Multi-Basin** functions aggregate `K` basins (each a full Rastrigin/Rosenb
 The runner evaluates the four EvoGrad modes — **Classical**, **Differentiable**, **Adaptive**, **Full** — and, by default, the **pymoo** and **Adam** (multi-start) baselines:
 
 ```bash
+# Install the manuscript's pinned cross-library baseline
+pip install -r requirements-benchmarks.txt
+
 # 30 runs of DE on the full CEC 2017 suite in 30D (vs pymoo + Adam)
 python -m evograd.benchmarks.run_benchmark_functions -a DE -s cec2017 -D 30 -r 30
 
@@ -494,6 +507,37 @@ The **Adaptive** variant reaches the lowest mean/variance, while **Full** matche
 
 > Full experimental details are in the paper (see [Citation](#-citation)).
 
+### Reproducibility note (v0.3.0)
+
+The results reported above and in the paper were produced with the **paper-era
+code (`evograd-diff` v0.1.2)**. Version 0.3.0 incorporates a set of
+post-publication audit fixes that can change the *absolute* numbers, so results
+obtained with v0.3.0 may differ from the published tables. The corrections that
+affect benchmark values include:
+
+- a restored cyclic term in the Expanded Schaffer F6 component, which changes
+  CEC 2017 **F16, F19, F26–F30**;
+- NaN-free CEC 2017 composition weights at component centres and the true CEC
+  **F9** optimum location (F8/F9 numerics otherwise preserved);
+- matched **pymoo** GA/CMA-ES baseline configurations (population size, per-gene
+  operator probabilities, un-normalised CMA-ES step size);
+- a consistent **Adam** baseline (fitness paired with the evaluated iterate);
+- **scale-invariant** softmax recombination in differentiable CMA-ES; and
+- consistent differentiable-**PSO** state (the committed position is re-evaluated so
+  population and fitness agree; optimisation quality is unchanged).
+
+These changes primarily affect absolute fitness values and the cross-library
+baseline comparisons; the paper's qualitative findings (all EvoGrad variants and
+baselines within a run share the same objective implementation) are not expected
+to change, but the exact significance percentages and per-function rankings will.
+**To reproduce the paper exactly, install the paper-era release:**
+
+```bash
+pip install evograd-diff==0.1.2
+```
+
+See [`CHANGELOG.md`](CHANGELOG.md) for the complete list of changes.
+
 ## 📖 Citation
 
 EvoGrad was accepted at the **IEEE Congress on Evolutionary Computation (CEC) 2026**. If you use EvoGrad in your research, please cite:
@@ -524,4 +568,4 @@ Contributions are welcome! Please feel free to submit a Pull Request. For major
 ## 🙏 Acknowledgements
 
 - Inspired by [pymoo](https://pymoo.org/) for API design
-- Built with [PyTorch](https://pytorch.org/) for automatic differentiation
+- Built with [PyTorch](https://pytorch.org/) for automatic differentiation

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/README.md

@@ -58,22 +58,26 @@ problem = Problem(
 
 # Run with Genetic Algorithm
 ga = GA(pop_size=100, differentiable=True)
-result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42,
+                  lr_pop=-1, lr_hyper=-1)
 print(f"GA Best: {result.best_fitness:.6f}")
 
 # Run with Differential Evolution
 de = DE(pop_size=100, variant="DE/rand/1/bin", adaptive=True)
-result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42,
+                  lr_hyper=-1)
 print(f"DE Best: {result.best_fitness:.6f}")
 
 # Run with Particle Swarm Optimisation
 pso = PSO(pop_size=100, adaptive=True, differentiable=True)
-result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42,
+                  lr_pop=-1, lr_hyper=-1)
 print(f"PSO Best: {result.best_fitness:.6f}")
 
 # Run with CMA-ES
 cmaes = CMAES(sigma=0.5, adaptive=True)
-result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42)
+result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42,
+                  lr_hyper=-1)
 print(f"CMA-ES Best: {result.best_fitness:.6f}")
 ```
 
@@ -113,6 +117,12 @@ ga = GA(
 | Operator `adaptive=True` | Operator uses Gumbel-Softmax/Binary-Concrete for gradient flow |
 | Operator `learn_*=True` | Operator hyperparameters become learnable `nn.Parameter` |
 
+Gradient optimizers are opt-in at the `minimize()` call. `lr_pop=None` and
+`lr_hyper=None` (the defaults) perform no backpropagation; use `-1` to select
+EvoGrad's algorithm-specific learning rate or pass a numeric value. For strict
+classical behavior, also construct the algorithm with `differentiable=False`
+and `adaptive=False`.
+
 ### Differential Evolution (DE)
 
 DE uses **algorithm-level flags** for adaptive hyperparameters and differentiable population:
@@ -426,6 +436,9 @@ The **Multi-Basin** functions aggregate `K` basins (each a full Rastrigin/Rosenb
 The runner evaluates the four EvoGrad modes — **Classical**, **Differentiable**, **Adaptive**, **Full** — and, by default, the **pymoo** and **Adam** (multi-start) baselines:
 
 ```bash
+# Install the manuscript's pinned cross-library baseline
+pip install -r requirements-benchmarks.txt
+
 # 30 runs of DE on the full CEC 2017 suite in 30D (vs pymoo + Adam)
 python -m evograd.benchmarks.run_benchmark_functions -a DE -s cec2017 -D 30 -r 30
 
@@ -467,6 +480,37 @@ The **Adaptive** variant reaches the lowest mean/variance, while **Full** matche
 
 > Full experimental details are in the paper (see [Citation](#-citation)).
 
+### Reproducibility note (v0.3.0)
+
+The results reported above and in the paper were produced with the **paper-era
+code (`evograd-diff` v0.1.2)**. Version 0.3.0 incorporates a set of
+post-publication audit fixes that can change the *absolute* numbers, so results
+obtained with v0.3.0 may differ from the published tables. The corrections that
+affect benchmark values include:
+
+- a restored cyclic term in the Expanded Schaffer F6 component, which changes
+  CEC 2017 **F16, F19, F26–F30**;
+- NaN-free CEC 2017 composition weights at component centres and the true CEC
+  **F9** optimum location (F8/F9 numerics otherwise preserved);
+- matched **pymoo** GA/CMA-ES baseline configurations (population size, per-gene
+  operator probabilities, un-normalised CMA-ES step size);
+- a consistent **Adam** baseline (fitness paired with the evaluated iterate);
+- **scale-invariant** softmax recombination in differentiable CMA-ES; and
+- consistent differentiable-**PSO** state (the committed position is re-evaluated so
+  population and fitness agree; optimisation quality is unchanged).
+
+These changes primarily affect absolute fitness values and the cross-library
+baseline comparisons; the paper's qualitative findings (all EvoGrad variants and
+baselines within a run share the same objective implementation) are not expected
+to change, but the exact significance percentages and per-function rankings will.
+**To reproduce the paper exactly, install the paper-era release:**
+
+```bash
+pip install evograd-diff==0.1.2
+```
+
+See [`CHANGELOG.md`](CHANGELOG.md) for the complete list of changes.
+
 ## 📖 Citation
 
 EvoGrad was accepted at the **IEEE Congress on Evolutionary Computation (CEC) 2026**. If you use EvoGrad in your research, please cite:
@@ -497,4 +541,4 @@ Contributions are welcome! Please feel free to submit a Pull Request. For major
 ## 🙏 Acknowledgements
 
 - Inspired by [pymoo](https://pymoo.org/) for API design
-- Built with [PyTorch](https://pytorch.org/) for automatic differentiation
+- Built with [PyTorch](https://pytorch.org/) for automatic differentiation

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/evograd/__init__.py

@@ -36,7 +36,8 @@ Quick Start
 ... )
 >>>
 >>> # Run optimization
->>> result = minimize(problem, algorithm, termination=MaxEvaluations(10000), seed=42)
+>>> result = minimize(problem, algorithm, termination=MaxEvaluations(10000), seed=42,
+...                   lr_pop=-1, lr_hyper=-1)
 >>> print(f"Best fitness: {result.best_fitness:.6f}")
 
 Architecture
@@ -57,11 +58,11 @@ Authors
 Andrea Tangherloni <andrea.tangherloni@unibocconi.it>
 """
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "Andrea Tangherloni"
 
 __all__ = [
     # Version info
     "__version__",
     "__author__",
-    ]
+    ]

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/evograd/algorithms/__init__.py

@@ -18,7 +18,7 @@ the dependency injection pattern for operators.
 
 Example:
     >>> from evograd.algorithms import GA, DE, SHADE, PSO, CMAES
-    >>> from evograd.core import Problem, minimize
+    >>> from evograd.core import Problem, minimize, MaxEvaluations
     >>> 
     >>> problem = Problem(
     ...     objective=lambda x: (x**2).sum(dim=-1),
@@ -29,27 +29,27 @@ Example:
     >>> 
     >>> # Genetic Algorithm
     >>> ga = GA(pop_size=100, differentiable=True)
-    >>> result = minimize(problem, ga, max_evals=10000)
+    >>> result = minimize(problem, ga, MaxEvaluations(10000), lr_pop=-1, lr_hyper=-1)
     >>> 
     >>> # Differential Evolution
     >>> de = DE(pop_size=100, variant="DE/rand/1/bin", adaptive=True)
-    >>> result = minimize(problem, de, max_evals=10000)
+    >>> result = minimize(problem, de, MaxEvaluations(10000), lr_hyper=-1)
     >>> 
     >>> # SHADE (Self-Adaptive DE)
     >>> shade = SHADE(pop_size=100, memory_size=100)
-    >>> result = minimize(problem, shade, max_evals=10000)
+    >>> result = minimize(problem, shade, MaxEvaluations(10000))
     >>> 
     >>> # L-SHADE (SHADE with population reduction)
     >>> lshade = LSHADE(pop_size_init=18*30, pop_size_min=4)
-    >>> result = minimize(problem, lshade, max_evals=10000)
+    >>> result = minimize(problem, lshade, MaxEvaluations(10000))
     >>> 
     >>> # Particle Swarm Optimisation
     >>> pso = PSO(pop_size=100, adaptive=True)
-    >>> result = minimize(problem, pso, max_evals=10000)
+    >>> result = minimize(problem, pso, MaxEvaluations(10000), lr_hyper=-1)
     >>> 
     >>> # CMA-ES
     >>> cmaes = CMAES(pop_size=50, adaptive=True)
-    >>> result = minimize(problem, cmaes, max_evals=10000)
+    >>> result = minimize(problem, cmaes, MaxEvaluations(10000), lr_hyper=-1)
 """
 
 # Genetic Algorithm
@@ -135,4 +135,4 @@ __all__ = [
     "cmaes_adaptive",
     "cmaes_ipop",
     "cmaes_bipop",
-]
+]

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/evograd/algorithms/cmaes.py

@@ -83,6 +83,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.relaxations import standard_normal, log_param
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -233,6 +234,7 @@ class CMAES(Algorithm):
         repair: Optional[nn.Module] = None,
         adaptive: bool = False,
         differentiable: bool = False,
+        selection_temperature: float = 1.0,
         dtype: torch.dtype = torch.float32,
     ) -> None:
         self.adaptive = adaptive
@@ -243,6 +245,9 @@ class CMAES(Algorithm):
         self._init_c1 = c1
         self._init_cmu = cmu
         self._init_damps = damps
+        if selection_temperature <= 0:
+            raise ValueError("selection_temperature must be > 0")
+        self._init_selection_temperature = selection_temperature
         
         # Restart parameters
         self._restarts = restarts
@@ -286,7 +291,9 @@ class CMAES(Algorithm):
         # Compute default population size if not provided
         if self._requested_pop_size is None:
             n_var = self.problem.n_var
-            self.pop_size = 4 + int(3 * math.log(n_var))
+            default_size = 4 + int(3 * math.log(n_var))
+            factor = float(getattr(self, "_pop_size_factor", 1.0))
+            self.pop_size = max(2, int(round(default_size * factor)))
             self.n_offsprings = self.pop_size
 
     def _setup(self) -> None:
@@ -302,6 +309,16 @@ class CMAES(Algorithm):
         
         # Compute recombination weights
         self._setup_weights()
+
+        log_temperature = torch.tensor(
+            math.log(self._init_selection_temperature),
+            device=self.device,
+            dtype=self.dtype,
+        )
+        if self.adaptive:
+            self._log_selection_temperature = nn.Parameter(log_temperature)
+        else:
+            self.register_buffer("_log_selection_temperature", log_temperature)
         
         # Setup mean
         self._setup_mean(n_var)
@@ -386,9 +403,7 @@ class CMAES(Algorithm):
                 with torch.no_grad():
                     self._log_sigma.fill_(math.log(sigma_val))
             else:
-                self._log_sigma = nn.Parameter(
-                    torch.tensor(sigma_val, device=self.device, dtype=self.dtype).log()
-                )
+                self._log_sigma = log_param(sigma_val, device=self.device, dtype=self.dtype)
         else:
             if hasattr(self, '_sigma_buffer'):
                 self._sigma_buffer.fill_(sigma_val)
@@ -467,9 +482,7 @@ class CMAES(Algorithm):
                     self._to_logit(cmu).to(device=self.device, dtype=self.dtype)
                 )
                 # damps is positive, store as log
-                self._log_damps = nn.Parameter(
-                    torch.tensor(damps, device=self.device, dtype=self.dtype).log()
-                )
+                self._log_damps = log_param(damps, device=self.device, dtype=self.dtype)
         else:
             if not hasattr(self, '_cc'):
                 self.register_buffer("_cc", torch.tensor(cc, device=self.device, dtype=self.dtype))
@@ -520,6 +533,37 @@ class CMAES(Algorithm):
         """Covariance matrix C = L @ L.T."""
         L = self.L
         return L @ L.T
+
+    @property
+    def selection_temperature(self) -> Tensor:
+        """Temperature used by differentiable fitness recombination."""
+        return self._log_selection_temperature.exp()
+
+    def _soft_recombination_weights(self, fitness: Tensor) -> Tensor:
+        """Scale-invariant temperature-controlled fitness weights."""
+        spread = fitness.detach().std(unbiased=False).clamp_min(
+            torch.finfo(fitness.dtype).tiny
+        )
+        temperature = self.selection_temperature * spread
+        # Center first so a constant, non-zero fitness vector does not overflow
+        # when its (correctly tiny) scale is used as the temperature.
+        centered = fitness - fitness.detach().mean()
+        return torch.softmax(-centered / temperature, dim=0)
+
+    def _coefficients_for_mass(self, mu_eff: Tensor, soft: bool) -> tuple:
+        """Return CMA adaptation coefficients consistent with selection mass."""
+        if not soft or self.adaptive:
+            return self.cc, self.cs, self.c1, self.cmu, self.damps
+
+        d = float(self.n_var)
+        m = float(mu_eff.detach())
+        cc = (4 + m / d) / (d + 4 + 2 * m / d)
+        cs = (m + 2) / (d + m + 5)
+        c1 = 2 / ((d + 1.3) ** 2 + m)
+        cmu = max(0.0, min(1 - c1, 2 * (m - 2 + 1 / m) / ((d + 2) ** 2 + m)))
+        damps = 1 + 2 * max(0, math.sqrt((m - 1) / (d + 1)) - 1) + cs
+        values = (cc, cs, c1, cmu, damps)
+        return tuple(torch.as_tensor(v, device=self.device, dtype=self.dtype) for v in values)
     
     @property
     def p_sigma(self) -> Tensor:
@@ -587,7 +631,7 @@ class CMAES(Algorithm):
         N, D = self.pop_size, self.n_var
         
         # Sample standard normal
-        z = torch.randn(N, D, device=self.device, dtype=self.dtype)
+        z = standard_normal(N, D, device=self.device, dtype=self.dtype)
         
         # Transform: y = L @ z
         L = self.L
@@ -619,6 +663,20 @@ class CMAES(Algorithm):
             offspring = torch.clamp(offspring, self.xl, self.xu)
         
         return offspring
+
+    def forward(self, reduction: str = "mean", live_selection: bool = True) -> Tensor:
+        """Build a generation graph with soft fitness recombination.
+
+        Classical CMA-ES keeps the requested generic reduction. Differentiable
+        and adaptive variants use temperature-controlled softmax weights so
+        selection itself contributes gradients, matching the manuscript model.
+        """
+        loss = super().forward(reduction=reduction, live_selection=live_selection)
+        if not (self.differentiable or self.adaptive):
+            return loss
+        fitness = self._pending_fitness
+        weights = self._soft_recombination_weights(fitness)
+        return (weights * fitness).sum()
     
     def _advance(self, offspring: Tensor, offspring_fitness: Tensor) -> None:
         """
@@ -628,30 +686,52 @@ class CMAES(Algorithm):
             offspring: Offspring population [pop_size, n_var].
             offspring_fitness: Fitness values [pop_size].
         """
-        N, D = self.pop_size, self.n_var
-        mu = self._mu
-        
-        # Sort by fitness (ascending for minimization)
-        sorted_indices = torch.argsort(offspring_fitness)
-        selected_indices = sorted_indices[:mu]
-        
-        # Get selected y vectors (in transformed space)
-        y_selected = self._pending_y[selected_indices]  # [mu, D]
-        
+        if self.differentiable or self.adaptive:
+            recombination_weights = self._soft_recombination_weights(offspring_fitness)
+            y_selected = self._pending_y
+            soft_recombination = True
+        else:
+            sorted_indices = torch.argsort(offspring_fitness)
+            selected_indices = sorted_indices[:self._mu]
+            y_selected = self._pending_y[selected_indices]
+            recombination_weights = self._weights
+            soft_recombination = False
+
+        mu_eff = 1.0 / recombination_weights.square().sum().clamp_min(self._eps)
+        cc, cs, c1, cmu, damps = self._coefficients_for_mass(
+            mu_eff,
+            soft_recombination,
+        )
+        self._last_mu_eff = float(mu_eff.detach())
+
         # Weighted recombination in y-space
-        y_w = (self._weights.unsqueeze(-1) * y_selected).sum(dim=0)  # [D]
+        y_w = (recombination_weights.unsqueeze(-1) * y_selected).sum(dim=0)
         
         # Update mean
         new_mean = self.mean + self.sigma * y_w
         
         # Update evolution paths
-        new_p_sigma, new_p_c, h_sigma = self._update_evolution_paths(y_w)
+        new_p_sigma, new_p_c, h_sigma = self._update_evolution_paths(
+            y_w,
+            mu_eff,
+            cc,
+            cs,
+            soft_recombination,
+        )
         
         # Update covariance
-        new_L = self._update_covariance(y_selected, new_p_c, h_sigma)
+        new_L = self._update_covariance(
+            y_selected,
+            new_p_c,
+            h_sigma,
+            recombination_weights,
+            cc,
+            c1,
+            cmu,
+        )
         
         # Update step-size
-        new_sigma = self._update_sigma(new_p_sigma)
+        new_sigma = self._update_sigma(new_p_sigma, cs, damps)
         
         # Commit updates
         self._commit_updates(
@@ -685,7 +765,14 @@ class CMAES(Algorithm):
         del self._pending_z
         del self._pending_y
     
-    def _update_evolution_paths(self, y_w: Tensor) -> tuple:
+    def _update_evolution_paths(
+        self,
+        y_w: Tensor,
+        mu_eff: Tensor,
+        cc: Tensor,
+        cs: Tensor,
+        soft: bool,
+    ) -> tuple:
         """
         Update evolution paths p_σ and p_c.
         
@@ -696,7 +783,6 @@ class CMAES(Algorithm):
             Tuple of (new_p_sigma, new_p_c, h_sigma).
         """
         D = self.n_var
-        mu_eff = self._mu_eff
         
         # Compute C^(-1/2) @ y_w using L^(-1) @ y_w
         L = self.L
@@ -704,8 +790,15 @@ class CMAES(Algorithm):
         z_w = torch.linalg.solve_triangular(L, y_w.unsqueeze(-1), upper=False).squeeze(-1)
         
         # Update p_sigma (conjugate evolution path)
-        cs = self.cs
-        new_p_sigma = (1 - cs) * self.p_sigma + math.sqrt(cs * (2 - cs) * mu_eff) * z_w
+        if soft:
+            sigma_path_scale = torch.sqrt(cs * (2 - cs) * mu_eff)
+            covariance_path_scale = torch.sqrt(cc * (2 - cc) * mu_eff)
+        else:
+            # Preserve the original classical implementation's scalar path
+            # exactly; only relaxed recombination needs tensor-valued scales.
+            sigma_path_scale = math.sqrt(cs * (2 - cs) * mu_eff)
+            covariance_path_scale = math.sqrt(cc * (2 - cc) * mu_eff)
+        new_p_sigma = (1 - cs) * self.p_sigma + sigma_path_scale * z_w
         
         # Heaviside function h_sigma (smooth approximation)
         norm_p_sigma = new_p_sigma.norm()
@@ -713,8 +806,7 @@ class CMAES(Algorithm):
         h_sigma = torch.sigmoid(10 * (threshold - norm_p_sigma / self._chi_n))
         
         # Update p_c (evolution path for covariance)
-        cc = self.cc
-        new_p_c = (1 - cc) * self.p_c + h_sigma * math.sqrt(cc * (2 - cc) * mu_eff) * y_w
+        new_p_c = (1 - cc) * self.p_c + h_sigma * covariance_path_scale * y_w
         
         return new_p_sigma, new_p_c, h_sigma
     
@@ -723,6 +815,10 @@ class CMAES(Algorithm):
         y_selected: Tensor,
         new_p_c: Tensor,
         h_sigma: Tensor,
+        recombination_weights: Tensor,
+        cc: Tensor,
+        c1: Tensor,
+        cmu: Tensor,
     ) -> Tensor:
         """
         Update covariance matrix C.
@@ -736,9 +832,6 @@ class CMAES(Algorithm):
             New Cholesky factor L.
         """
         D = self.n_var
-        c1 = self.c1
-        cmu = self.cmu
-        cc = self.cc
         
         # Current covariance
         L = self.L
@@ -749,7 +842,7 @@ class CMAES(Algorithm):
         
         # Rank-mu update
         rank_mu = (
-            self._weights.unsqueeze(-1).unsqueeze(-1) * 
+            recombination_weights.unsqueeze(-1).unsqueeze(-1) *
             y_selected.unsqueeze(-1) * y_selected.unsqueeze(-2)
         ).sum(dim=0)
         
@@ -853,7 +946,12 @@ class CMAES(Algorithm):
         
         return L_identity
     
-    def _update_sigma(self, new_p_sigma: Tensor) -> Tensor:
+    def _update_sigma(
+        self,
+        new_p_sigma: Tensor,
+        cs: Tensor,
+        damps: Tensor,
+    ) -> Tensor:
         """
         Update step-size using CSA (Cumulative Step-size Adaptation).
         
@@ -863,9 +961,6 @@ class CMAES(Algorithm):
         Returns:
             New step-size.
         """
-        cs = self.cs
-        damps = self.damps
-        
         # Step-size update factor
         norm_p_sigma = new_p_sigma.norm()
         factor = torch.exp((cs / damps) * (norm_p_sigma / self._chi_n - 1))
@@ -1101,6 +1196,10 @@ class CMAES(Algorithm):
         if self.adaptive:
             # Sigma in (1e-10, 1e10)
             self._log_sigma.clamp_(min=-23, max=23)
+            self._log_selection_temperature.clamp_(
+                min=math.log(0.05),
+                max=math.log(100.0),
+            )
             
             # Ensure c1 + cmu <= 1
             c1 = torch.sigmoid(self._c1_logit)
@@ -1121,7 +1220,8 @@ class CMAES(Algorithm):
         return {
             'pop_size': self.pop_size,
             'mu': self._mu,
-            'mu_eff': self._mu_eff,
+            'selection_temperature': float(self.selection_temperature.detach()),
+            'mu_eff': getattr(self, '_last_mu_eff', self._mu_eff),
             'sigma': float(self.sigma.item()),
             'cc': float(self.cc.item()),
             'cs': float(self.cs.item()),
@@ -1365,4 +1465,4 @@ def cmaes_bipop(
         incpopsize=incpopsize,
         bipop=True,
         **kwargs,
-    )
+    )

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/evograd/algorithms/de.py

@@ -63,6 +63,8 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.repair import clamp_to_bounds
+from evograd.operators.relaxations import log_param
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -308,9 +310,7 @@ class DE(Algorithm):
         # Setup F parameter
         if self.adaptive:
             # Learnable F stored as log(F) for positivity
-            self._log_F = nn.Parameter(
-                torch.tensor(self._init_F, device=self.device, dtype=self.dtype).log()
-            )
+            self._log_F = log_param(self._init_F, device=self.device, dtype=self.dtype)
         else:
             self.register_buffer(
                 "_F_buffer",
@@ -627,7 +627,7 @@ class DE(Algorithm):
             trial = self.repair(trial, self.xl, self.xu)
         else:
             # Default: clamp to bounds
-            trial = torch.clamp(trial, self.xl, self.xu)
+            trial = clamp_to_bounds(trial, self.xl, self.xu)
         
         return trial
     

{evograd_diff-0.2.0 → evograd_diff-0.3.0}/evograd/algorithms/ga.py

@@ -57,7 +57,7 @@ Example:
 Reference:
     Holland, J. H. (1992). Genetic Algorithms. Scientific American.
     Goldberg, D. E. (1989). Genetic Algorithms in Search, Optimization,
-        and Machine Learning.
+    and Machine Learning.
 """
 
 from __future__ import annotations
@@ -69,6 +69,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.repair import clamp_to_bounds
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -274,7 +275,15 @@ class GA(Algorithm):
         
         # 3. MUTATION: Introduce variation
         offspring = self.mutation(offspring, self.xl, self.xu)
-        
+
+        # 4. Bound safety: when no repair operator is configured, clamp to the
+        #    box so out-of-bounds points are never evaluated regardless of the
+        #    mutation/crossover operators (mirrors DE/PSO/CMA-ES/SHADE). When a
+        #    repair IS configured the base step/forward applies it. This is a
+        #    no-op for the bounded default PolynomialMutation.
+        if self.repair is None:
+            offspring = clamp_to_bounds(offspring, self.xl, self.xu)
+
         return offspring
     
     def _advance(self, offspring: Tensor, offspring_fitness: Tensor) -> None: