evograd-diff 0.1.2__tar.gz → 0.2.1__tar.gz

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evograd-diff
-Version: 0.1.2
+Version: 0.2.1
 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
@@ -25,15 +25,18 @@ Requires-Dist: seaborn>=0.13.2
 Requires-Dist: torch>=2.11.0
 Description-Content-Type: text/markdown
 
-# EvoGrad: Metaheuristics in a Differentiable Wonderland
+# EvoGrad: Accelerated Metaheuristics in a Differentiable Wonderland
 
 <p align="center">
   <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+">
   <img src="https://img.shields.io/badge/pytorch-2.0+-orange.svg" alt="PyTorch 2.0+">
   <img src="https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg" alt="License: Apache-2.0">
+  <img src="https://img.shields.io/badge/IEEE%20CEC-2026-success.svg" alt="IEEE CEC 2026">
  
 </p>
 
+> 🎉 **EvoGrad has been accepted at [IEEE CEC 2026](#-citation)!**
+
 **EvoGrad** is a PyTorch-based framework for differentiable Evolutionary Computation and Swarm Intelligence. It bridges classical population-based optimisation with modern differentiable programming by enabling gradient flow through evolutionary operators.
 
 ## 🌟 Key Features
@@ -421,11 +424,88 @@ EvoGrad makes evolutionary algorithms differentiable through:
 
 ## 📊 Benchmarks
 
-TODO
+EvoGrad ships a self-contained, **PyTorch-native benchmark suite** (`evograd.benchmarks`) together with a parallel runner that evaluates every algorithm in its four operating modes against two reference baselines.
+
+### Function library
+
+All functions share a common `BenchmarkFunction` interface (`f(x)` on an `(N, n_var)` batch, plus `.bounds` and the known optimum) and run on CPU/GPU/MPS.
+
+| Category | Functions |
+|----------|-----------|
+| **Classical — unimodal** | Sphere, Ellipsoid, SumOfDifferentPowers, Schwefel 2.22, Cigar, Discus, BentCigar, Rosenbrock, DixonPrice, Powell, Trid |
+| **Classical — multimodal** | Rastrigin, Ackley, Griewank, Schwefel, Levy, Michalewicz, Zakharov, Weierstrass, Alpine, Salomon, Styblinski–Tang |
+| **CEC 2017** (`F1`–`F30`) | Simple/unimodal (F1–F10), Hybrid (F11–F20), Composition (F21–F30) — the full competition suite, **rewritten from scratch in PyTorch** |
+| **Multi-Basin / Smoothed-Funnel** | `MultiBasinRastrigin`, `MultiBasinRosenbrock`, `DeceptiveLandscape` — designed for differentiable EAs |
+| **Transforms** | Shifted / Rotated / Scaled / Asymmetric / Oscillated / Biased wrappers for building custom variants |
+
+```python
+import torch
+from evograd.benchmarks.functions import Sphere, Rastrigin, get_cec2017_function, MultiBasinRastrigin
+
+f = get_cec2017_function(14, n_var=30)   # CEC 2017 F14 in 30D
+y = f(torch.randn(100, 30))              # batch evaluation -> shape [100]
+```
+
+The **Multi-Basin** functions aggregate `K` basins (each a full Rastrigin/Rosenbrock landscape) with a smooth *log-sum-exp* minimum, so the surface stays differentiable everywhere while still trapping pure gradient descent in distractor basins — exactly the setting where population search combined with gradient refinement pays off.
+
+### Running the benchmarks
+
+The runner evaluates the four EvoGrad modes — **Classical**, **Differentiable**, **Adaptive**, **Full** — and, by default, the **pymoo** and **Adam** (multi-start) baselines:
+
+```bash
+# 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
+
+# CMA-ES on the multi-basin functions, on GPU
+python -m evograd.benchmarks.run_benchmark_functions -a CMAES -s funnel -D 30 --device cuda
+
+# List every available function and suite
+python -m evograd.benchmarks.run_benchmark_functions --list_functions
+```
+
+Key flags: `-a {DE,SHADE,PSO,GA,CMAES,ADAM}`, `-s` suite (`classical`, `standard`, `cec2017[_simple|_hybrid|_composition]`, `funnel`, …), `-D` dimensionality, `-r` runs, `-p` population size, `--no_pymoo` / `--no_adam` to drop baselines. Plotting utilities live in `plot_benchmarks.py`.
+
+### Results
+
+The three differentiable variants are compared against the **Classical** baseline and pymoo:
+
+- **Adaptive** — learnable hyperparameters, purely stochastic variation (no gradient through the population).
+- **Diff** (Differentiable) — fixed hyperparameters, gradients refine the population.
+- **Full** — both: learnable hyperparameters *and* gradient-based population refinement.
+
+**CEC 2017 (30D & 100D).** 29 functions (F2 excluded, per the competition), search space `[-100, 100]^D`, 100 individuals, `10000·D` evaluations, 30 independent paired runs, one-sided Wilcoxon signed-rank test with Benjamini–Hochberg correction. Highlights:
+
+- Differentiable variants are **statistically significantly better than the classical baseline in ~31% of all comparisons**, and **never substantially worse** — gradient refinement can be added to EAs safely.
+- Gains concentrate where local refinement helps most: **GA (70.1%)** and **DE (46.0%)** of comparisons improved, versus **PSO (6.9%)** and **CMA-ES (1.1%)**, which already include strong built-in adaptation.
+- Across variants, **Full (41.4%) > Adaptive (35.3%) > Diff (16.4%)** — combining hyperparameter learning with population refinement helps the most, increasingly so at 100D.
+- CMA-ES is the strongest method overall (especially on hybrid/composition functions), and EvoGrad runs ~**3× faster** than the pymoo baselines on CPU *despite* the added gradient computation.
+
+**Multi-Basin Rastrigin** (`D=30`, bounds `[-5, 5]^D`, 150,000 evaluations, 30 runs). Every CMA-ES variant locates the global basin (best fitness `0.00`); a multi-start **Adam** baseline (100 parallel solutions) stays trapped in distractor basins:
+
+| Configuration | Best | Mean | Std | Time (s) |
+|---|---|---|---|---|
+| CMA-ES Classical | 0.00 | 2.22 | 3.04 | 25.66 |
+| CMA-ES Differentiable | 0.00 | 1.49 | 2.16 | 9.77 |
+| CMA-ES Adaptive | 0.00 | **0.99** | **1.36** | 45.24 |
+| CMA-ES Full | 0.00 | 1.29 | 2.12 | **7.94** |
+| Adam (multi-start, pop-based) | 116.41 | 153.77 | 13.98 | 3.88 |
+
+The **Adaptive** variant reaches the lowest mean/variance, while **Full** matches it closely at the **fastest** runtime — gradient flow yields large speed-ups while population search secures the global basin. Adam alone is **>2 orders of magnitude worse**, confirming that pure gradient descent cannot escape distractor basins.
+
+> Full experimental details are in the paper (see [Citation](#-citation)).
 
 ## 📖 Citation
 
-TBA
+EvoGrad was accepted at the **IEEE Congress on Evolutionary Computation (CEC) 2026**. If you use EvoGrad in your research, please cite:
+
+```bibtex
+@inproceedings{citterio2026evograd,
+  title     = {{EvoGrad}: Accelerated Metaheuristics in a Differentiable Wonderland},
+  author    = {Citterio, Beatrice F. R. and Papetti, Daniele M. and Dimitri, Giovanna Maria and Tangherloni, Andrea},
+  booktitle = {Proceedings of the IEEE Congress on Evolutionary Computation (CEC)},
+  year      = {2026},
+}
+```
 
 ## 📄 License
 

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/README.md

@@ -1,12 +1,15 @@
-# EvoGrad: Metaheuristics in a Differentiable Wonderland
+# EvoGrad: Accelerated Metaheuristics in a Differentiable Wonderland
 
 <p align="center">
   <img src="https://img.shields.io/badge/python-3.9+-blue.svg" alt="Python 3.9+">
   <img src="https://img.shields.io/badge/pytorch-2.0+-orange.svg" alt="PyTorch 2.0+">
   <img src="https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg" alt="License: Apache-2.0">
+  <img src="https://img.shields.io/badge/IEEE%20CEC-2026-success.svg" alt="IEEE CEC 2026">
  
 </p>
 
+> 🎉 **EvoGrad has been accepted at [IEEE CEC 2026](#-citation)!**
+
 **EvoGrad** is a PyTorch-based framework for differentiable Evolutionary Computation and Swarm Intelligence. It bridges classical population-based optimisation with modern differentiable programming by enabling gradient flow through evolutionary operators.
 
 ## 🌟 Key Features
@@ -394,11 +397,88 @@ EvoGrad makes evolutionary algorithms differentiable through:
 
 ## 📊 Benchmarks
 
-TODO
+EvoGrad ships a self-contained, **PyTorch-native benchmark suite** (`evograd.benchmarks`) together with a parallel runner that evaluates every algorithm in its four operating modes against two reference baselines.
+
+### Function library
+
+All functions share a common `BenchmarkFunction` interface (`f(x)` on an `(N, n_var)` batch, plus `.bounds` and the known optimum) and run on CPU/GPU/MPS.
+
+| Category | Functions |
+|----------|-----------|
+| **Classical — unimodal** | Sphere, Ellipsoid, SumOfDifferentPowers, Schwefel 2.22, Cigar, Discus, BentCigar, Rosenbrock, DixonPrice, Powell, Trid |
+| **Classical — multimodal** | Rastrigin, Ackley, Griewank, Schwefel, Levy, Michalewicz, Zakharov, Weierstrass, Alpine, Salomon, Styblinski–Tang |
+| **CEC 2017** (`F1`–`F30`) | Simple/unimodal (F1–F10), Hybrid (F11–F20), Composition (F21–F30) — the full competition suite, **rewritten from scratch in PyTorch** |
+| **Multi-Basin / Smoothed-Funnel** | `MultiBasinRastrigin`, `MultiBasinRosenbrock`, `DeceptiveLandscape` — designed for differentiable EAs |
+| **Transforms** | Shifted / Rotated / Scaled / Asymmetric / Oscillated / Biased wrappers for building custom variants |
+
+```python
+import torch
+from evograd.benchmarks.functions import Sphere, Rastrigin, get_cec2017_function, MultiBasinRastrigin
+
+f = get_cec2017_function(14, n_var=30)   # CEC 2017 F14 in 30D
+y = f(torch.randn(100, 30))              # batch evaluation -> shape [100]
+```
+
+The **Multi-Basin** functions aggregate `K` basins (each a full Rastrigin/Rosenbrock landscape) with a smooth *log-sum-exp* minimum, so the surface stays differentiable everywhere while still trapping pure gradient descent in distractor basins — exactly the setting where population search combined with gradient refinement pays off.
+
+### Running the benchmarks
+
+The runner evaluates the four EvoGrad modes — **Classical**, **Differentiable**, **Adaptive**, **Full** — and, by default, the **pymoo** and **Adam** (multi-start) baselines:
+
+```bash
+# 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
+
+# CMA-ES on the multi-basin functions, on GPU
+python -m evograd.benchmarks.run_benchmark_functions -a CMAES -s funnel -D 30 --device cuda
+
+# List every available function and suite
+python -m evograd.benchmarks.run_benchmark_functions --list_functions
+```
+
+Key flags: `-a {DE,SHADE,PSO,GA,CMAES,ADAM}`, `-s` suite (`classical`, `standard`, `cec2017[_simple|_hybrid|_composition]`, `funnel`, …), `-D` dimensionality, `-r` runs, `-p` population size, `--no_pymoo` / `--no_adam` to drop baselines. Plotting utilities live in `plot_benchmarks.py`.
+
+### Results
+
+The three differentiable variants are compared against the **Classical** baseline and pymoo:
+
+- **Adaptive** — learnable hyperparameters, purely stochastic variation (no gradient through the population).
+- **Diff** (Differentiable) — fixed hyperparameters, gradients refine the population.
+- **Full** — both: learnable hyperparameters *and* gradient-based population refinement.
+
+**CEC 2017 (30D & 100D).** 29 functions (F2 excluded, per the competition), search space `[-100, 100]^D`, 100 individuals, `10000·D` evaluations, 30 independent paired runs, one-sided Wilcoxon signed-rank test with Benjamini–Hochberg correction. Highlights:
+
+- Differentiable variants are **statistically significantly better than the classical baseline in ~31% of all comparisons**, and **never substantially worse** — gradient refinement can be added to EAs safely.
+- Gains concentrate where local refinement helps most: **GA (70.1%)** and **DE (46.0%)** of comparisons improved, versus **PSO (6.9%)** and **CMA-ES (1.1%)**, which already include strong built-in adaptation.
+- Across variants, **Full (41.4%) > Adaptive (35.3%) > Diff (16.4%)** — combining hyperparameter learning with population refinement helps the most, increasingly so at 100D.
+- CMA-ES is the strongest method overall (especially on hybrid/composition functions), and EvoGrad runs ~**3× faster** than the pymoo baselines on CPU *despite* the added gradient computation.
+
+**Multi-Basin Rastrigin** (`D=30`, bounds `[-5, 5]^D`, 150,000 evaluations, 30 runs). Every CMA-ES variant locates the global basin (best fitness `0.00`); a multi-start **Adam** baseline (100 parallel solutions) stays trapped in distractor basins:
+
+| Configuration | Best | Mean | Std | Time (s) |
+|---|---|---|---|---|
+| CMA-ES Classical | 0.00 | 2.22 | 3.04 | 25.66 |
+| CMA-ES Differentiable | 0.00 | 1.49 | 2.16 | 9.77 |
+| CMA-ES Adaptive | 0.00 | **0.99** | **1.36** | 45.24 |
+| CMA-ES Full | 0.00 | 1.29 | 2.12 | **7.94** |
+| Adam (multi-start, pop-based) | 116.41 | 153.77 | 13.98 | 3.88 |
+
+The **Adaptive** variant reaches the lowest mean/variance, while **Full** matches it closely at the **fastest** runtime — gradient flow yields large speed-ups while population search secures the global basin. Adam alone is **>2 orders of magnitude worse**, confirming that pure gradient descent cannot escape distractor basins.
+
+> Full experimental details are in the paper (see [Citation](#-citation)).
 
 ## 📖 Citation
 
-TBA
+EvoGrad was accepted at the **IEEE Congress on Evolutionary Computation (CEC) 2026**. If you use EvoGrad in your research, please cite:
+
+```bibtex
+@inproceedings{citterio2026evograd,
+  title     = {{EvoGrad}: Accelerated Metaheuristics in a Differentiable Wonderland},
+  author    = {Citterio, Beatrice F. R. and Papetti, Daniele M. and Dimitri, Giovanna Maria and Tangherloni, Andrea},
+  booktitle = {Proceedings of the IEEE Congress on Evolutionary Computation (CEC)},
+  year      = {2026},
+}
+```
 
 ## 📄 License
 

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/evograd/__init__.py

@@ -57,7 +57,7 @@ Authors
 Andrea Tangherloni <andrea.tangherloni@unibocconi.it>
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"
 __author__ = "Andrea Tangherloni"
 
 __all__ = [

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/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
@@ -386,9 +387,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 +466,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))
@@ -587,7 +584,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

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/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.1.2 → evograd_diff-0.2.1}/evograd/algorithms/pso.py

@@ -52,6 +52,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
@@ -357,7 +358,7 @@ class PSO(Algorithm):
         pos_repaired = torch.where(above, 2 * self.xu - position, pos_repaired)
         
         # Clamp to ensure within bounds (in case of large violations)
-        pos_repaired = torch.clamp(pos_repaired, self.xl, self.xu)
+        pos_repaired = clamp_to_bounds(pos_repaired, self.xl, self.xu)
         
         # Reverse velocity at boundaries
         vel_repaired = velocity.clone()
@@ -473,7 +474,7 @@ class PSO(Algorithm):
                 old_pos = new_pos - new_velocity          # P₀
                 grad_delta = self._population.data - old_pos  # −lr·∇
                 combined = new_pos + grad_delta           # P₀ + v − lr·∇
-                combined = torch.clamp(combined, self.xl, self.xu)
+                combined = clamp_to_bounds(combined, self.xl, self.xu)
                 self._population.copy_(combined)
             else:
                 self._population.copy_(new_pos)

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/evograd/algorithms/shade.py

@@ -65,6 +65,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.relaxations import standard_normal
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -197,7 +198,7 @@ class SHADEMemory:
         
         # Sample from Normal distribution
         sigma = 0.1  # Standard SHADE scale parameter
-        CR = mu_CR + sigma * torch.randn(n, device=device, dtype=dtype)
+        CR = mu_CR + sigma * standard_normal(n, device=device, dtype=dtype)
         
         # Truncate to [0, 1]
         CR = torch.clamp(CR, min=0.0, max=1.0)
@@ -520,7 +521,7 @@ class SHADE(Algorithm):
             
             # Reparameterized Normal for CR
             sigma = 0.1
-            eps = torch.randn(N, device=self.device, dtype=self.dtype)
+            eps = standard_normal(N, device=self.device, dtype=self.dtype)
             CR = mu_CR + sigma * eps
             CR = torch.clamp(CR, min=0.0, max=1.0)
         else:
@@ -886,8 +887,6 @@ class LSHADE(SHADE):
         adaptive: bool = False,
         differentiable: bool = False,
         selection_temperature: float = 1.0,
-        seed: Optional[int] = None,
-        device: Optional[Union[str, torch.device]] = None,
         dtype: torch.dtype = torch.float32,
     ) -> None:
         self.pop_size_init = pop_size_init  # Will be set in _setup if None
@@ -909,8 +908,6 @@ class LSHADE(SHADE):
             differentiable=differentiable,
             adaptive=adaptive,
             selection_temperature=selection_temperature,
-            seed=seed,
-            device=device,
             dtype=dtype,
         )
     
@@ -919,8 +916,10 @@ class LSHADE(SHADE):
         # Set default pop_size_init based on problem dimension
         if self.pop_size_init is None:
             self.pop_size_init = 18 * self.problem.n_var
-            self._pop_size = self.pop_size_init
-        
+        # Always initialise the working population size (fixes target_pop_size
+        # AttributeError when pop_size_init was provided explicitly).
+        self._pop_size = self.pop_size_init
+
         # Create success-history memory with L-SHADE archive size
         self.memory = SHADEMemory.create(
             H=self.memory_size,

evograd_diff-0.2.1/evograd/benchmarks/functions/cec2017/_base.py

@@ -0,0 +1,51 @@
+"""
+Shared base for CEC 2017 functions.
+
+Single source of truth for the bias, shift/rotation loading, default bounds, and
+the shift+rotate transform used by the simple and hybrid CEC 2017 families
+(previously copy-pasted in simple.py and hybrid.py).
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from torch import Tensor
+
+from ..base import BenchmarkFunction
+from . import data as cec_data
+
+
+class CEC2017Base(BenchmarkFunction):
+    """Base for shifted+rotated CEC 2017 functions (search space [-100, 100]^D)."""
+
+    def __init__(
+        self,
+        func_num: int,
+        n_var: int = 10,
+        rotation: Optional[Tensor] = None,
+        shift: Optional[Tensor] = None,
+        seed: Optional[int] = None,
+    ):
+        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
+
+        self.func_num = func_num
+        self.bias = func_num * 100.0  # F_i* = i * 100
+
+        if rotation is not None:
+            self.rotation = rotation
+        else:
+            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
+
+        if shift is not None:
+            self.shift = shift
+        else:
+            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
+
+    def default_bounds(self) -> Tuple[float, float]:
+        return (-100.0, 100.0)
+
+    def _shift_rotate(self, x: Tensor) -> Tensor:
+        """Apply the shift + rotation transform (single source of truth)."""
+        shift = self.shift.to(x.device, x.dtype)
+        rotation = self.rotation.to(x.device, x.dtype)
+        return cec_data.shift_rotate(x, shift, rotation)

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/evograd/benchmarks/functions/cec2017/hybrid.py

@@ -26,11 +26,15 @@ from torch import Tensor
 from ..base import BenchmarkFunction
 from . import basic
 from . import data as cec_data
+from ._base import CEC2017Base
 
 
-class CEC2017HybridFunction(BenchmarkFunction):
-    """Base class for CEC 2017 hybrid functions."""
-    
+class CEC2017HybridFunction(CEC2017Base):
+    """Base class for CEC 2017 hybrid functions (adds a shuffle permutation).
+
+    Shared shift/rotation handling is inherited from CEC2017Base (see _base.py).
+    """
+
     def __init__(
         self,
         func_num: int,
@@ -40,47 +44,13 @@ class CEC2017HybridFunction(BenchmarkFunction):
         shuffle: Optional[Tensor] = None,
         seed: Optional[int] = None,
     ):
-        """
-        Initialize CEC 2017 hybrid function.
-        
-        Args:
-            func_num: Function number (11-20).
-            n_var: Number of variables.
-            rotation: Optional rotation matrix.
-            shift: Optional shift vector.
-            shuffle: Optional shuffle permutation.
-            seed: Random seed for generating transforms if not provided.
-        """
-        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
-        
-        self.func_num = func_num
-        self.bias = func_num * 100.0
-        
-        # Load or generate transforms
-        if rotation is not None:
-            self.rotation = rotation
-        else:
-            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
-        
-        if shift is not None:
-            self.shift = shift
-        else:
-            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
-        
+        super().__init__(func_num=func_num, n_var=n_var,
+                         rotation=rotation, shift=shift, seed=seed)
         if shuffle is not None:
             self.shuffle = shuffle
         else:
             self.shuffle = cec_data.get_shuffle(func_num, n_var, seed=seed)
-    
-    def default_bounds(self) -> Tuple[float, float]:
-        return (-100.0, 100.0)
-    
-    def _shift_rotate(self, x: Tensor) -> Tensor:
-        """Apply shift and rotation transformation."""
-        shift = self.shift.to(x.device, x.dtype)
-        rotation = self.rotation.to(x.device, x.dtype)
-        return cec_data.shift_rotate(x, shift, rotation)
-    
+
     def _shuffle_and_partition(self, x: Tensor, partitions: List[float]) -> List[Tensor]:
         """Apply shuffle and partition."""
         shuffle = self.shuffle.to(x.device)

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/evograd/benchmarks/functions/cec2017/simple.py

@@ -26,54 +26,17 @@ from torch import Tensor
 from ..base import BenchmarkFunction
 from . import basic
 from . import data as cec_data
+from ._base import CEC2017Base
 
 
-class CEC2017Function(BenchmarkFunction):
-    """Base class for CEC 2017 functions with shift and rotation support."""
-    
-    def __init__(
-        self,
-        func_num: int,
-        n_var: int = 10,
-        rotation: Optional[Tensor] = None,
-        shift: Optional[Tensor] = None,
-        seed: Optional[int] = None,
-    ):
-        """
-        Initialize CEC 2017 function.
-        
-        Args:
-            func_num: Function number (1-30).
-            n_var: Number of variables (2, 10, 20, 30, 50, or 100 for official data).
-            rotation: Optional rotation matrix. If None, loads from data or generates.
-            shift: Optional shift vector. If None, loads from data or generates.
-            seed: Random seed for generating transforms if not provided.
-        """
-        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
-        
-        self.func_num = func_num
-        self.bias = func_num * 100.0  # F_i* = i * 100
-        
-        # Load or generate rotation matrix
-        if rotation is not None:
-            self.rotation = rotation
-        else:
-            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
-        
-        # Load or generate shift vector
-        if shift is not None:
-            self.shift = shift
-        else:
-            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
-    
-    def default_bounds(self) -> Tuple[float, float]:
-        return (-100.0, 100.0)
-    
-    def _shift_rotate(self, x: Tensor) -> Tensor:
-        """Apply shift and rotation transformation."""
-        shift = self.shift.to(x.device, x.dtype)
-        rotation = self.rotation.to(x.device, x.dtype)
-        return cec_data.shift_rotate(x, shift, rotation)
+class CEC2017Function(CEC2017Base):
+    """Base class for CEC 2017 simple functions (shift + rotation).
+
+    The shared __init__, default_bounds, and _shift_rotate live in
+    CEC2017Base (see _base.py).
+    """
+
+    pass
 
 
 class CEC2017_F1(CEC2017Function):

{evograd_diff-0.1.2 → evograd_diff-0.2.1}/evograd/core/algorithm.py

@@ -523,26 +523,65 @@ class Algorithm(nn.Module, ABC):
         
         return self.state.best_fitness
     
-    def forward(self) -> Tensor:
+    def forward(self, reduction: str = "mean", live_selection: bool = True) -> Tensor:
         """
         PyTorch forward pass for differentiable optimisation.
-        
+
         In differentiable mode, this builds a computation graph
-        through the entire generation, returning the best fitness
-        as a differentiable scalar loss. Call update_state() after
+        through the entire generation and reduces the per-offspring
+        fitness to a scalar loss. Call update_state() after
         loss.backward() and optimizer.step() to commit changes.
-        
+
+        Args:
+            reduction: How to reduce the (n_offsprings,) offspring fitness
+                into the scalar loss that is backpropagated:
+                - 'mean' (default): average fitness — gradient reaches the
+                  whole population, driving every member downhill.
+                - 'sum': total fitness — same per-member gradient direction
+                  as 'mean', scaled by n_offsprings.
+                - 'min': best offspring only — gradient flows solely through
+                  the single best offspring's ancestry (sparse signal).
+            live_selection: Whether selection routing carries gradient back to
+                the population.
+                - True (default, "live"): re-evaluate the current population so
+                  the selection logits depend on the live parameter — the
+                  Gumbel-Softmax selection gradient then reaches the population
+                  (fully end-to-end differentiable generation). For a
+                  deterministic objective this re-evaluation reproduces the
+                  committed fitness values exactly, so it is graph
+                  reconstruction, not new sampling: it is intentionally NOT
+                  counted in the evaluation budget (n_evals). It is, however, a
+                  real extra objective pass (wall-clock/FLOPs). For a stochastic
+                  objective the values may differ from the committed fitness.
+                - False ("detached", memetic): selection uses the cached,
+                  detached committed fitness as fixed routing weights; gradient
+                  only refines positions. Cheaper (no extra pass), lower
+                  variance, and the correct choice for stochastic objectives.
+
         Returns:
-            Best fitness as a scalar tensor (for backprop).
-        
+            Reduced offspring fitness as a scalar tensor (for backprop).
+
         Raises:
             RuntimeError: If algorithm not initialized.
+            ValueError: If reduction is not one of 'mean', 'sum', 'min'.
         """
         if not self._is_initialized:
             raise RuntimeError(
                 "Algorithm not initialized. Call initialize(problem) first."
             )
-        
+
+        if reduction not in ("mean", "sum", "min"):
+            raise ValueError(
+                f"reduction must be one of 'mean', 'sum', 'min'; got {reduction!r}"
+            )
+
+        # Live selection: attach a fresh autograd graph to the parent fitness so
+        # selection gradients flow into the population. Deliberately does NOT
+        # increment n_evals (values match the committed fitness for a
+        # deterministic objective — this only rebuilds the graph).
+        if live_selection:
+            self.state.fitness = self._evaluate(self.population)
+
         # Generate offspring (differentiable)
         offspring = self._infill()
         
@@ -561,7 +600,12 @@ class Algorithm(nn.Module, ABC):
         self._pending_offspring = offspring
         self._pending_fitness = offspring_fitness
         
-        # Return best fitness as loss
+        # Reduce per-offspring fitness to the scalar loss for backprop.
+        if reduction == "mean":
+            return offspring_fitness.mean()
+        if reduction == "sum":
+            return offspring_fitness.sum()
+        # reduction == "min"
         return offspring_fitness.min()
     
     @torch.no_grad()