Samplers and Adaptation

# Access sampling functionality
from cma.sampler import GaussFullSampler, GaussStandardSampler
from cma.restricted_gaussian_sampler import RestrictedGaussianSampler

class GaussFullSampler:
    """
    Full Gaussian sampler with complete covariance matrix.
    
    Standard CMA-ES sampler that maintains and updates full covariance matrix.
    """
    
    def __init__(self, N, **kwargs):
        """
        Initialize Gaussian sampler.
        
        Parameters:
        -----------
        N : int
            Problem dimension.
        """
        pass
    
    def sample(self, number, update=None):
        """
        Sample candidate solutions.
        
        Parameters:
        -----------
        number : int
            Number of samples to generate.
        update : bool, optional
            Whether to update internal state.
            
        Returns:
        --------
        list[array]
            List of sampled solutions.
        """
        pass

class GaussStandardSampler:
    """
    Standard Gaussian sampler for basic sampling needs.
    """
    
    def __init__(self, N, **kwargs):
        """Initialize standard Gaussian sampler."""
        pass

class RestrictedGaussianSampler:
    """
    Gaussian sampler with restrictions on eigenvalue range.
    
    Prevents numerical issues by restricting condition number of
    covariance matrix within reasonable bounds.
    """
    
    def __init__(self, dimension, **kwargs):
        """
        Initialize restricted sampler.
        
        Parameters:
        -----------
        dimension : int
            Problem dimension.
        """
        pass

# Step-size adaptation methods
from cma.sigma_adaptation import CMAAdaptSigmaCSA, CMAAdaptSigmaTPA

class CMAAdaptSigmaCSA:
    """
    Cumulative Step-size Adaptation (CSA) for CMA-ES.
    
    Classic step-size adaptation method that adjusts global step-size
    based on evolution path length and direction.
    """
    
    def __init__(self, dimension, **kwargs):
        """
        Initialize CSA adaptation.
        
        Parameters:
        -----------
        dimension : int
            Problem dimension.
        """
        pass
    
    def update(self, es, **kwargs):
        """
        Update step-size based on evolution path.
        
        Parameters:
        -----------
        es : CMAEvolutionStrategy
            Evolution strategy instance.
        """
        pass

class CMAAdaptSigmaTPA:
    """
    Two-Point Adaptation (TPA) for step-size control.
    
    Alternative adaptation method using two reference points.
    """
    
    def __init__(self, dimension, **kwargs):
        """Initialize TPA adaptation."""
        pass
    
    def update(self, es, **kwargs):
        """Update step-size using TPA method."""
        pass

# Recombination weight computation
from cma.recombination_weights import RecombinationWeights

class RecombinationWeights:
    """
    Compute and manage recombination weights for parent selection.
    
    Determines how much each parent contributes to the next generation
    mean and covariance matrix updates.
    """
    
    def __init__(self, number_of_weights, **kwargs):
        """
        Initialize recombination weights.
        
        Parameters:
        -----------
        number_of_weights : int
            Number of parent solutions (mu).
        """
        pass
    
    @property
    def weights(self):
        """array: Current recombination weights."""
        pass
    
    @property
    def mueff(self):
        """float: Effective parent population size."""
        pass
    
    @property
    def diversity_emphasis(self):
        """float: Emphasis on population diversity."""
        pass

import cma
from cma.sampler import GaussFullSampler

# Configure custom sampler
options = {
    'CMA_sampler': GaussFullSampler,
    'CMA_sampler_options': {'eigenmethod': 1}
}

es = cma.CMAEvolutionStrategy([0, 0, 0], 0.5, options)

# Optimization with custom sampler
while not es.stop():
    X = es.ask()
    es.tell(X, [cma.ff.sphere(x) for x in X])

import cma
from cma.sigma_adaptation import CMAAdaptSigmaCSA

# Configure step-size adaptation
options = {
    'AdaptSigma': CMAAdaptSigmaCSA,
    'CSA_dampfac': 1.0,  # Damping factor
    'CSA_damp_mueff_exponent': 0.5
}

es = cma.CMAEvolutionStrategy([1, 2, 3], 0.3, options)

# Monitor step-size evolution
while not es.stop():
    X = es.ask()
    es.tell(X, [cma.ff.rosen(x) for x in X])
    
    if es.countiter % 10 == 0:
        print(f"Iteration {es.countiter}: sigma = {es.sigma:.6f}")

import cma
from cma.recombination_weights import RecombinationWeights

# Custom recombination weights
def create_custom_weights(mu):
    """Create custom recombination weights."""
    weights = RecombinationWeights(mu)
    # Modify weights for specific requirements
    return weights

options = {
    'CMA_recombination_weights': create_custom_weights,
    'popsize': 20
}

es = cma.CMAEvolutionStrategy([0] * 5, 0.8, options)

# Enable mirrored sampling for improved efficiency
options = {
    'CMA_mirrors': 0.5,  # Fraction of mirrored solutions  
    'CMA_mirrormethod': 2  # Mirroring method
}

es = cma.CMAEvolutionStrategy([1, 1, 1], 0.5, options)

while not es.stop():
    X = es.ask()
    # Note: Some solutions in X are mirrored versions
    es.tell(X, [objective_function(x) for x in X])

# Enable elitist selection
options = {
    'CMA_elitist': True,  # Use elitist variant
    'CMA_elitist_percentage': 0.1  # Percentage of elite solutions
}

es = cma.CMAEvolutionStrategy([0, 0, 0], 0.5, options)