evograd-diff 0.1.0__py3-none-any.whl

evograd/benchmarks/functions/__init__.py

@@ -0,0 +1,229 @@
+"""
+EvoGrad Benchmark Functions.
+
+This package provides a comprehensive set of benchmark functions for
+testing and comparing optimization algorithms.
+
+Categories:
+- Classical: Standard test functions (Sphere, Rosenbrock, Rastrigin, etc.)
+- CEC 2017: Competition benchmark suite (F1-F30)
+- Smoothed Funnel: Multi-basin problems designed for differentiable EAs
+- Transforms: Wrappers for creating shifted/rotated variants
+
+Usage:
+    >>> from evograd.benchmarks.functions import Sphere, Rastrigin
+    >>> from evograd.benchmarks.functions import CEC2017_F1, get_cec2017_function
+    >>> from evograd.benchmarks.functions import SmoothedMultiFunnel
+    >>> 
+    >>> # Create function with default bounds
+    >>> sphere = Sphere(n_var=30)
+    >>> 
+    >>> # Create function with custom bounds
+    >>> sphere = Sphere(n_var=30, xl=-5.0, xu=5.0)
+    >>> 
+    >>> # Evaluate population
+    >>> x = torch.randn(100, 30)
+    >>> f = sphere(x)  # Shape: [100]
+    >>> 
+    >>> # Get bounds
+    >>> lb, ub = sphere.bounds
+    >>>
+    >>> # CEC 2017 functions
+    >>> f1 = CEC2017_F1(n_var=10)
+    >>> f15 = get_cec2017_function(15, n_var=10)
+    >>>
+    >>> # Smoothed multi-funnel (designed for differentiable EAs)
+    >>> funnel = SmoothedMultiFunnel(n_var=10, tau=1.0, delta=10.0)
+"""
+
+from .base import BenchmarkFunction, CompositeFunction
+
+from .classical import (
+    # Unimodal
+    Sphere,
+    Ellipsoid,
+    SumOfDifferentPowers,
+    Schwefel222,
+    Cigar,
+    Discus,
+    BentCigar,
+    Rosenbrock,
+    DixonPrice,
+    Powell,
+    Trid,
+    # Multimodal
+    Rastrigin,
+    Ackley,
+    Griewank,
+    Schwefel,
+    Levy,
+    Michalewicz,
+    Zakharov,
+    Weierstrass,
+    Alpine,
+    Salomon,
+    StyblinskiTang,
+    # Registry
+    CLASSICAL_FUNCTIONS,
+)
+
+from .transforms import (
+    ShiftedFunction,
+    RotatedFunction,
+    ShiftedRotatedFunction,
+    ScaledFunction,
+    AsymmetricFunction,
+    OscillatedFunction,
+    BiasedFunction,
+    generate_rotation_matrix,
+    generate_shift_vector,
+)
+
+# CEC 2017 Benchmark Suite
+from .cec2017 import (
+    # Simple functions (F1-F10)
+    CEC2017_F1,
+    CEC2017_F2,
+    CEC2017_F3,
+    CEC2017_F4,
+    CEC2017_F5,
+    CEC2017_F6,
+    CEC2017_F7,
+    CEC2017_F8,
+    CEC2017_F9,
+    CEC2017_F10,
+    # Hybrid functions (F11-F20)
+    CEC2017_F11,
+    CEC2017_F12,
+    CEC2017_F13,
+    CEC2017_F14,
+    CEC2017_F15,
+    CEC2017_F16,
+    CEC2017_F17,
+    CEC2017_F18,
+    CEC2017_F19,
+    CEC2017_F20,
+    # Composition functions (F21-F30)
+    CEC2017_F21,
+    CEC2017_F22,
+    CEC2017_F23,
+    CEC2017_F24,
+    CEC2017_F25,
+    CEC2017_F26,
+    CEC2017_F27,
+    CEC2017_F28,
+    CEC2017_F29,
+    CEC2017_F30,
+    # Registries
+    CEC2017_FUNCTIONS,
+    ALL_CEC2017_CLASSES,
+    # Utilities
+    get_function as get_cec2017_function,
+)
+
+# Smoothed Multi-Funnel Functions (designed for differentiable EAs)
+from .smoothed_funnel import (
+    # Core utilities
+    log_sum_exp_min,
+    random_orthogonal_matrix,
+    # Benchmark functions
+    MultiBasinRastrigin,
+    MultiBasinRosenbrock,
+    DeceptiveLandscape,
+    # Registry
+    SMOOTHED_FUNNEL_FUNCTIONS,
+)
+
+# Combined registry of all functions
+ALL_FUNCTIONS = {
+    **CLASSICAL_FUNCTIONS,
+    **CEC2017_FUNCTIONS,
+    **SMOOTHED_FUNNEL_FUNCTIONS,
+}
+
+__all__ = [
+    # Base
+    "BenchmarkFunction",
+    "CompositeFunction",
+    # Classical - Unimodal
+    "Sphere",
+    "Ellipsoid",
+    "SumOfDifferentPowers",
+    "Schwefel222",
+    "Cigar",
+    "Discus",
+    "BentCigar",
+    "Rosenbrock",
+    "DixonPrice",
+    "Powell",
+    "Trid",
+    # Classical - Multimodal
+    "Rastrigin",
+    "Ackley",
+    "Griewank",
+    "Schwefel",
+    "Levy",
+    "Michalewicz",
+    "Zakharov",
+    "Weierstrass",
+    "Alpine",
+    "Salomon",
+    "StyblinskiTang",
+    # Transforms
+    "ShiftedFunction",
+    "RotatedFunction",
+    "ShiftedRotatedFunction",
+    "ScaledFunction",
+    "AsymmetricFunction",
+    "OscillatedFunction",
+    "BiasedFunction",
+    "generate_rotation_matrix",
+    "generate_shift_vector",
+    # CEC 2017 - Simple (F1-F10)
+    "CEC2017_F1",
+    "CEC2017_F2",
+    "CEC2017_F3",
+    "CEC2017_F4",
+    "CEC2017_F5",
+    "CEC2017_F6",
+    "CEC2017_F7",
+    "CEC2017_F8",
+    "CEC2017_F9",
+    "CEC2017_F10",
+    # CEC 2017 - Hybrid (F11-F20)
+    "CEC2017_F11",
+    "CEC2017_F12",
+    "CEC2017_F13",
+    "CEC2017_F14",
+    "CEC2017_F15",
+    "CEC2017_F16",
+    "CEC2017_F17",
+    "CEC2017_F18",
+    "CEC2017_F19",
+    "CEC2017_F20",
+    # CEC 2017 - Composition (F21-F30)
+    "CEC2017_F21",
+    "CEC2017_F22",
+    "CEC2017_F23",
+    "CEC2017_F24",
+    "CEC2017_F25",
+    "CEC2017_F26",
+    "CEC2017_F27",
+    "CEC2017_F28",
+    "CEC2017_F29",
+    "CEC2017_F30",
+    # CEC 2017 utilities
+    "CEC2017_FUNCTIONS",
+    "ALL_CEC2017_CLASSES",
+    "get_cec2017_function",
+    # Smoothed Multi-Funnel (for differentiable EAs)
+    "log_sum_exp_min",
+    "random_orthogonal_matrix",
+    "MultiBasinRastrigin",
+    "MultiBasinRosenbrock",
+    "DeceptiveLandscape",
+    "SMOOTHED_FUNNEL_FUNCTIONS",
+    # Registries
+    "CLASSICAL_FUNCTIONS",
+    "ALL_FUNCTIONS",
+]

evograd/benchmarks/functions/base.py

@@ -0,0 +1,217 @@
+"""
+Base class for benchmark functions.
+
+All benchmark functions inherit from BenchmarkFunction and implement
+the __call__ method for evaluation. Bounds can be specified per-function
+or overridden at instantiation.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+
+
+class BenchmarkFunction(ABC):
+    """
+    Abstract base class for benchmark optimization functions.
+    
+    All benchmark functions support:
+    - Configurable dimensionality (n_var)
+    - Configurable bounds (xl, xu) - can be scalar or per-dimension
+    - Known optimal value and location
+    - Batch evaluation for populations
+    
+    Args:
+        n_var: Number of decision variables (dimensions).
+        xl: Lower bound(s). Scalar or tensor of shape [n_var].
+        xu: Upper bound(s). Scalar or tensor of shape [n_var].
+    
+    Example:
+        >>> sphere = Sphere(n_var=10)
+        >>> x = torch.randn(100, 10)  # Population of 100 individuals
+        >>> f = sphere(x)  # Shape: [100]
+        
+        >>> # Custom bounds
+        >>> sphere = Sphere(n_var=10, xl=-5.0, xu=5.0)
+    """
+    
+    # Class attributes (can be overridden in subclasses)
+    name: str = "base_function"
+    optimal_value: float = 0.0
+    
+    def __init__(
+        self,
+        n_var: int = 30,
+        xl: Optional[Union[float, Tensor]] = None,
+        xu: Optional[Union[float, Tensor]] = None,
+    ):
+        """
+        Initialize benchmark function.
+        
+        Args:
+            n_var: Number of decision variables.
+            xl: Lower bound(s). If None, uses default_bounds().
+            xu: Upper bound(s). If None, uses default_bounds().
+        """
+        self.n_var = n_var
+        
+        # Get default bounds
+        default_lb, default_ub = self.default_bounds()
+        
+        # Set lower bounds
+        if xl is None:
+            xl = default_lb
+        if isinstance(xl, (int, float)):
+            self._xl = torch.full((n_var,), float(xl))
+        else:
+            self._xl = xl.clone() if isinstance(xl, Tensor) else torch.tensor(xl)
+            if self._xl.numel() == 1:
+                self._xl = self._xl.expand(n_var).clone()
+        
+        # Set upper bounds
+        if xu is None:
+            xu = default_ub
+        if isinstance(xu, (int, float)):
+            self._xu = torch.full((n_var,), float(xu))
+        else:
+            self._xu = xu.clone() if isinstance(xu, Tensor) else torch.tensor(xu)
+            if self._xu.numel() == 1:
+                self._xu = self._xu.expand(n_var).clone()
+        
+        # Compute optimal location (default: origin)
+        self._optimal_x = self._compute_optimal_x()
+    
+    @property
+    def xl(self) -> Tensor:
+        """Lower bounds as tensor of shape [n_var]."""
+        return self._xl
+    
+    @property
+    def xu(self) -> Tensor:
+        """Upper bounds as tensor of shape [n_var]."""
+        return self._xu
+    
+    @property
+    def bounds(self) -> Tuple[Tensor, Tensor]:
+        """Return (lower_bounds, upper_bounds) tuple."""
+        return (self._xl, self._xu)
+    
+    @property
+    def optimal_x(self) -> Tensor:
+        """Optimal solution location."""
+        return self._optimal_x
+    
+    def _compute_optimal_x(self) -> Tensor:
+        """
+        Compute the optimal solution location.
+        
+        Override in subclasses if optimal is not at origin.
+        """
+        return torch.zeros(self.n_var)
+    
+    @abstractmethod
+    def default_bounds(self) -> Tuple[float, float]:
+        """
+        Return default (lower, upper) bounds for this function.
+        
+        Returns:
+            Tuple of (lower_bound, upper_bound) scalars.
+        """
+        pass
+    
+    @abstractmethod
+    def __call__(self, x: Tensor) -> Tensor:
+        """
+        Evaluate the function at point(s) x.
+        
+        Args:
+            x: Decision variables of shape [..., n_var].
+               Can be single point [n_var] or batch [N, n_var].
+        
+        Returns:
+            Function values of shape [...] (same batch dimensions as input).
+        """
+        pass
+    
+    def to(self, device: torch.device) -> "BenchmarkFunction":
+        """Move bounds to specified device."""
+        self._xl = self._xl.to(device)
+        self._xu = self._xu.to(device)
+        self._optimal_x = self._optimal_x.to(device)
+        return self
+    
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"n_var={self.n_var}, "
+            f"xl={self._xl[0].item():.2f}, "
+            f"xu={self._xu[0].item():.2f})"
+        )
+    
+    def info(self) -> str:
+        """Return detailed information about the function."""
+        return (
+            f"Function: {self.name}\n"
+            f"  Dimensions: {self.n_var}\n"
+            f"  Bounds: [{self._xl[0].item():.2f}, {self._xu[0].item():.2f}]\n"
+            f"  Optimal value: {self.optimal_value}\n"
+            f"  Optimal location: {self._optimal_x[:3].tolist()}..."
+        )
+
+
+class CompositeFunction(BenchmarkFunction):
+    """
+    Composite function combining multiple base functions.
+    
+    Used for creating CEC-style hybrid and composition functions.
+    """
+    
+    def __init__(
+        self,
+        functions: list,
+        weights: Optional[Tensor] = None,
+        n_var: int = 30,
+        xl: Optional[Union[float, Tensor]] = None,
+        xu: Optional[Union[float, Tensor]] = None,
+    ):
+        """
+        Initialize composite function.
+        
+        Args:
+            functions: List of BenchmarkFunction instances.
+            weights: Weights for combining functions. If None, equal weights.
+            n_var: Number of decision variables.
+            xl: Lower bounds.
+            xu: Upper bounds.
+        """
+        self.functions = functions
+        self.n_functions = len(functions)
+        
+        if weights is None:
+            self.weights = torch.ones(self.n_functions) / self.n_functions
+        else:
+            self.weights = weights / weights.sum()
+        
+        # Use first function's bounds as default
+        if xl is None and functions:
+            xl = functions[0]._xl[0].item()
+        if xu is None and functions:
+            xu = functions[0]._xu[0].item()
+        
+        super().__init__(n_var=n_var, xl=xl, xu=xu)
+        self.name = "composite"
+    
+    def default_bounds(self) -> Tuple[float, float]:
+        return (-100.0, 100.0)
+    
+    def __call__(self, x: Tensor) -> Tensor:
+        """Weighted sum of component functions."""
+        result = torch.zeros(x.shape[:-1], device=x.device, dtype=x.dtype)
+        weights = self.weights.to(x.device, x.dtype)
+        
+        for i, func in enumerate(self.functions):
+            result = result + weights[i] * func(x)
+        
+        return result

evograd/benchmarks/functions/cec2017/__init__.py

@@ -0,0 +1,250 @@
+"""
+CEC 2017 Benchmark Functions for PyTorch.
+
+This package provides a comprehensive implementation of the CEC 2017
+benchmark suite for real-parameter single objective optimization.
+
+The suite consists of 30 functions:
+- F1-F10: Simple functions (shifted and rotated basic functions)
+- F11-F20: Hybrid functions (combinations of basic functions)
+- F21-F30: Composition functions (weighted combinations)
+
+All functions:
+- Accept PyTorch tensors
+- Support batch evaluation
+- Have bounds of [-100, 100]
+- Have optimal values of F_i* = i * 100
+
+Usage:
+    >>> from evograd.benchmarks.functions.cec2017 import CEC2017_F1, CEC2017_F10
+    >>> 
+    >>> # Create function with default settings
+    >>> f1 = CEC2017_F1(n_var=10)
+    >>> 
+    >>> # Evaluate population
+    >>> x = torch.randn(100, 10)
+    >>> fitness = f1(x)  # Shape: [100]
+    >>> 
+    >>> # Get optimal value
+    >>> print(f"Optimal value: {f1.optimal_value}")  # 100.0
+
+Supported dimensions: 2, 10, 20, 30, 50, 100 (for official data)
+Other dimensions will use randomly generated transforms.
+
+Reference:
+    N. H. Awad, M. Z. Ali, J. J. Liang, B. Y. Qu, and P. N. Suganthan,
+    "Problem Definitions and Evaluation Criteria for the CEC 2017 
+    Special Session and Competition on Single Objective Real-Parameter
+    Numerical Optimization," Technical Report, 2016.
+"""
+
+# Basic functions (stateless, for internal use)
+from .basic import (
+    bent_cigar,
+    sum_diff_pow,
+    zakharov,
+    rosenbrock,
+    rastrigin,
+    expanded_schaffers_f6,
+    lunacek_bi_rastrigin,
+    non_cont_rastrigin,
+    levy,
+    modified_schwefel,
+    high_conditioned_elliptic,
+    discus,
+    ackley,
+    weierstrass,
+    griewank,
+    katsuura,
+    happy_cat,
+    h_g_bat,
+    expanded_griewanks_plus_rosenbrock,
+    schaffers_f7,
+    BASIC_FUNCTIONS,
+)
+
+# Simple functions (F1-F10)
+from .simple import (
+    CEC2017_F1,
+    CEC2017_F2,
+    CEC2017_F3,
+    CEC2017_F4,
+    CEC2017_F5,
+    CEC2017_F6,
+    CEC2017_F7,
+    CEC2017_F8,
+    CEC2017_F9,
+    CEC2017_F10,
+    SIMPLE_FUNCTIONS,
+)
+
+# Hybrid functions (F11-F20)
+from .hybrid import (
+    CEC2017_F11,
+    CEC2017_F12,
+    CEC2017_F13,
+    CEC2017_F14,
+    CEC2017_F15,
+    CEC2017_F16,
+    CEC2017_F17,
+    CEC2017_F18,
+    CEC2017_F19,
+    CEC2017_F20,
+    HYBRID_FUNCTIONS,
+)
+
+# Composition functions (F21-F30)
+from .composition import (
+    CEC2017_F21,
+    CEC2017_F22,
+    CEC2017_F23,
+    CEC2017_F24,
+    CEC2017_F25,
+    CEC2017_F26,
+    CEC2017_F27,
+    CEC2017_F28,
+    CEC2017_F29,
+    CEC2017_F30,
+    COMPOSITION_FUNCTIONS,
+)
+
+# Data utilities
+from .data import (
+    data_available,
+    get_rotation,
+    get_rotation_cf,
+    get_shift,
+    get_shift_cf,
+    get_shuffle,
+    get_shuffle_cf,
+    generate_rotation_matrix,
+    generate_shift_vector,
+    generate_shuffle,
+    shift_rotate,
+    shuffle_and_partition,
+    SUPPORTED_DIMS,
+)
+
+
+# Combined registry of all CEC 2017 functions
+CEC2017_FUNCTIONS = {
+    **SIMPLE_FUNCTIONS,
+    **HYBRID_FUNCTIONS,
+    **COMPOSITION_FUNCTIONS,
+}
+
+# List of all function classes for iteration
+ALL_CEC2017_CLASSES = [
+    # Simple (F1-F10)
+    CEC2017_F1, CEC2017_F2, CEC2017_F3, CEC2017_F4, CEC2017_F5,
+    CEC2017_F6, CEC2017_F7, CEC2017_F8, CEC2017_F9, CEC2017_F10,
+    # Hybrid (F11-F20)
+    CEC2017_F11, CEC2017_F12, CEC2017_F13, CEC2017_F14, CEC2017_F15,
+    CEC2017_F16, CEC2017_F17, CEC2017_F18, CEC2017_F19, CEC2017_F20,
+    # Composition (F21-F30)
+    CEC2017_F21, CEC2017_F22, CEC2017_F23, CEC2017_F24, CEC2017_F25,
+    CEC2017_F26, CEC2017_F27, CEC2017_F28, CEC2017_F29, CEC2017_F30,
+]
+
+
+def get_function(func_num: int, n_var: int = 10, **kwargs):
+    """
+    Get CEC 2017 function by number.
+    
+    Args:
+        func_num: Function number (1-30).
+        n_var: Number of variables.
+        **kwargs: Additional arguments passed to the function constructor.
+    
+    Returns:
+        BenchmarkFunction instance.
+    
+    Example:
+        >>> f1 = get_function(1, n_var=10)
+        >>> f15 = get_function(15, n_var=30)
+    """
+    if func_num < 1 or func_num > 30:
+        raise ValueError(f"Function number must be 1-30, got {func_num}")
+    
+    func_class = ALL_CEC2017_CLASSES[func_num - 1]
+    return func_class(n_var=n_var, **kwargs)
+
+
+__all__ = [
+    # Basic functions
+    "bent_cigar",
+    "sum_diff_pow",
+    "zakharov",
+    "rosenbrock",
+    "rastrigin",
+    "expanded_schaffers_f6",
+    "lunacek_bi_rastrigin",
+    "non_cont_rastrigin",
+    "levy",
+    "modified_schwefel",
+    "high_conditioned_elliptic",
+    "discus",
+    "ackley",
+    "weierstrass",
+    "griewank",
+    "katsuura",
+    "happy_cat",
+    "h_g_bat",
+    "expanded_griewanks_plus_rosenbrock",
+    "schaffers_f7",
+    "BASIC_FUNCTIONS",
+    # Simple functions (F1-F10)
+    "CEC2017_F1",
+    "CEC2017_F2",
+    "CEC2017_F3",
+    "CEC2017_F4",
+    "CEC2017_F5",
+    "CEC2017_F6",
+    "CEC2017_F7",
+    "CEC2017_F8",
+    "CEC2017_F9",
+    "CEC2017_F10",
+    "SIMPLE_FUNCTIONS",
+    # Hybrid functions (F11-F20)
+    "CEC2017_F11",
+    "CEC2017_F12",
+    "CEC2017_F13",
+    "CEC2017_F14",
+    "CEC2017_F15",
+    "CEC2017_F16",
+    "CEC2017_F17",
+    "CEC2017_F18",
+    "CEC2017_F19",
+    "CEC2017_F20",
+    "HYBRID_FUNCTIONS",
+    # Composition functions (F21-F30)
+    "CEC2017_F21",
+    "CEC2017_F22",
+    "CEC2017_F23",
+    "CEC2017_F24",
+    "CEC2017_F25",
+    "CEC2017_F26",
+    "CEC2017_F27",
+    "CEC2017_F28",
+    "CEC2017_F29",
+    "CEC2017_F30",
+    "COMPOSITION_FUNCTIONS",
+    # Combined registries
+    "CEC2017_FUNCTIONS",
+    "ALL_CEC2017_CLASSES",
+    # Utilities
+    "get_function",
+    "data_available",
+    "get_rotation",
+    "get_rotation_cf",
+    "get_shift",
+    "get_shift_cf",
+    "get_shuffle",
+    "get_shuffle_cf",
+    "generate_rotation_matrix",
+    "generate_shift_vector",
+    "generate_shuffle",
+    "shift_rotate",
+    "shuffle_and_partition",
+    "SUPPORTED_DIMS",
+]