def __init__(self, solver_name, constrained): base.__init__(self) try: exec('from scipy.optimize import %s as solver' % solver_name) from numpy import concatenate, array except ImportError: raise ImportError( 'The necessary SciPy and/or NumPy classes/functions could not be imported') self.solver = solver self.constrained = constrained
def __init__( self, gen=500, elite=0.5, scale=0.3, variant=1, screen_output=False): """ Constructs a Cross-Entropy Algorithm (Python) USAGE: algorithm.py_cross_entropy(gen = 1, elite = 0.5, scale = 0.2, variant=1, screen_output = False)) NOTE: A multivariate normal distribution is used. The first sample is centered around the population champion. Covariance matrix and mean is evaluated using ind.best_x * gen: number of generations * elite: fraction of the population considered as elite (in (0,1]) * scale: scaling factor for the estimated covariance matrix * variant: algoritmic variant to use (one of [1,2]) 1. 'Canonical' - Covariance Matrix is evaluated as sum (x_(i+1)-mu_i)^T (x_(i+1)-mu_i) 2. 'Dario's' - Covariance Matrix is evaluated as sum (x_(i+1)-mu_i^T)^T (x_(i+1)-mu_i^T) * screen_output: activates screen_output (output at each generation) """ try: import numpy as np except ImportError: raise ImportError( "This algorithm needs numpy to run. Is numpy installed?") base.__init__(self) self.__gen = gen self.__elite = elite self.__scale = scale self.__screen_output = screen_output self.__weights = [] self.__variant = variant np.random.seed()
def __init__(self, gen=500, elite=0.5, scale=0.3, variant=1, screen_output=False): """ Constructs a Cross-Entropy Algorithm (Python) USAGE: algorithm.py_cross_entropy(gen = 1, elite = 0.5, scale = 0.2, variant=1, screen_output = False)) NOTE: A multivariate normal distribution is used. The first sample is centered around the population champion. Covariance matrix and mean is evaluated using ind.best_x * gen: number of generations * elite: fraction of the population considered as elite (in (0,1]) * scale: scaling factor for the estimated covariance matrix * variant: algoritmic variant to use (one of [1,2]) 1. 'Canonical' - Covariance Matrix is evaluated as sum (x_(i+1)-mu_i)^T (x_(i+1)-mu_i) 2. 'Dario's' - Covariance Matrix is evaluated as sum (x_(i+1)-mu_i^T)^T (x_(i+1)-mu_i^T) * screen_output: activates screen_output (output at each generation) """ try: import numpy as np except ImportError: raise ImportError( "This algorithm needs numpy to run. Is numpy installed?") base.__init__(self) self.__gen = gen self.__elite = elite self.__scale = scale self.__screen_output = screen_output self.__weights = [] self.__variant = variant np.random.seed()
def __init__(self, gen=500, cc=-1, cs=-1, c1=-1, cmu=-1, sigma0=0.5, ftol=1e-6, xtol=1e-6, memory=False, screen_output=False): """ Constructs a Covariance Matrix Adaptation Evolutionary Strategy (Python) USAGE: algorithm.py_cmaes(gen = 500, cc = -1, cs = -1, c1 = -1, cmu = -1, sigma0=0.5, ftol = 1e-6, xtol = 1e-6, memory = False, screen_output = False) NOTE: In our variant of the algorithm, particle memory is used to extract the elite and reinsertion is made aggressively ..... getting rid of the worst guy). Also, the bounds of the problem are enforced, as to allow PaGMO machinery to work. Fine control on each iteration can be achieved by calling the algo with gen=1 (algo state is stored, cmaes will continue at next call ... without initializing again all its state!!) * gen: number of generations * cc: time constant for C cumulation (in [0,1]) if -1 automatic values are set * cs: time constant for sigma cumulation (in [0,1]) if -1 automatic values are set * c1: learning rate for rank-1 update (in [0,1]) if -1 automatic values are set * cmu: learning rate for rank-mu update (in [0,1]) if -1 automatic values are set * sigma0: starting step (std) * xtol: stopping criteria on the x tolerance * ftol: stopping criteria on the f tolerance * memory: when True the algorithm preserves memory of covariance, step and more between successive runs * screen_output: activates screen_output (output at each generation) """ try: import numpy as np except ImportError: raise ImportError( "This algorithm needs numpy to run. Is numpy installed?") if (gen <= 0): raise ValueError("gen needs to be > 0") if ((cc < 0 or cc > 1) and not cc == -1): raise ValueError("cc needs to be in [0,1] or -1 for auto value") if ((cs < 0 or cs > 1) and not cc == -1): raise ValueError("cs needs to be in [0,1] or -1 for auto value") if ((c1 < 0 or c1 > 1) and not cc == -1): raise ValueError("c1 needs to be in [0,1] or -1 for auto value") if ((cmu < 0 or cmu > 1) and not cc == -1): raise ValueError("cmu needs to be in [0,1] or -1 for auto value") base.__init__(self) # Data members self.__cc = cc self.__cs = cs self.__c1 = c1 self.__cmu = cmu self.__gen = gen self.__xtol = xtol self.__ftol = ftol self.__sigma0 = sigma0 self.__memory = memory self.screen_output = screen_output # Algorithm memory self.__mean = 0 self.__variation = 0 self.__newpop = np.matrix([[1]]) self.__B = 0 self.__D = 0 self.__C = 0 self.__invsqrtC = 0 self.__pc = 0 self.__ps = 0 self.__counteval = 0 self.__eigeneval = 0 np.random.seed()
def __init__(self, solver, constrained): base.__init__(self) from numpy import concatenate, array self.solver = solver self.constrained = constrained
def __init__( self, gen=500, cc=-1, cs=-1, c1=-1, cmu=-1, sigma0=0.5, ftol=1e-6, xtol=1e-6, memory=False, screen_output=False): """ Constructs a Covariance Matrix Adaptation Evolutionary Strategy (Python) USAGE: algorithm.py_cmaes(gen = 500, cc = -1, cs = -1, c1 = -1, cmu = -1, sigma0=0.5, ftol = 1e-6, xtol = 1e-6, memory = False, screen_output = False) NOTE: In our variant of the algorithm, particle memory is used to extract the elite and reinsertion is made aggressively ..... getting rid of the worst guy). Also, the bounds of the problem are enforced, as to allow PaGMO machinery to work. Fine control on each iteration can be achieved by calling the algo with gen=1 (algo state is stored, cmaes will continue at next call ... without initializing again all its state!!) * gen: number of generations * cc: time constant for C cumulation (in [0,1]) if -1 automatic values are set * cs: time constant for sigma cumulation (in [0,1]) if -1 automatic values are set * c1: learning rate for rank-1 update (in [0,1]) if -1 automatic values are set * cmu: learning rate for rank-mu update (in [0,1]) if -1 automatic values are set * sigma0: starting step (std) * xtol: stopping criteria on the x tolerance * ftol: stopping criteria on the f tolerance * memory: when True the algorithm preserves memory of covariance, step and more between successive runs * screen_output: activates screen_output (output at each generation) """ try: import numpy as np except ImportError: raise ImportError( "This algorithm needs numpy to run. Is numpy installed?") if (gen <= 0): raise ValueError("gen needs to be > 0") if ((cc < 0 or cc > 1) and not cc == -1): raise ValueError("cc needs to be in [0,1] or -1 for auto value") if ((cs < 0 or cs > 1) and not cc == -1): raise ValueError("cs needs to be in [0,1] or -1 for auto value") if ((c1 < 0 or c1 > 1) and not cc == -1): raise ValueError("c1 needs to be in [0,1] or -1 for auto value") if ((cmu < 0 or cmu > 1) and not cc == -1): raise ValueError("cmu needs to be in [0,1] or -1 for auto value") base.__init__(self) # Data members self.__cc = cc self.__cs = cs self.__c1 = c1 self.__cmu = cmu self.__gen = gen self.__xtol = xtol self.__ftol = ftol self.__sigma0 = sigma0 self.__memory = memory self.screen_output = screen_output # Algorithm memory self.__mean = 0 self.__variation = 0 self.__newpop = np.matrix([[1]]) self.__B = 0 self.__D = 0 self.__C = 0 self.__invsqrtC = 0 self.__pc = 0 self.__ps = 0 self.__counteval = 0 self.__eigeneval = 0 np.random.seed()