def __init__(self, basef, translate=True, rotate=False, conditioning=None, asymmetry=None, oscillate=False, penalize=None, ): FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) self.desiredValue = basef.desiredValue self.toBeMinimized = basef.toBeMinimized if translate: self.xopt = (rand(self.xdim) - 0.5) * 9.8 self._diags = eye(self.xdim) self._R = eye(self.xdim) self._Q = eye(self.xdim) if conditioning is not None: self._diags = generateDiags(conditioning, self.xdim) if rotate: self._R = orth(rand(basef.xdim, basef.xdim)) if conditioning: self._Q = orth(rand(basef.xdim, basef.xdim)) tmp = lambda x: dot(self._Q, dot(self._diags, dot(self._R, x-self.xopt))) if asymmetry is not None: tmp2 = tmp tmp = lambda x: asymmetrify(tmp2(x), asymmetry) if oscillate: tmp3 = tmp tmp = lambda x: oscillatify(tmp3(x)) self.f = lambda x: basef.f(tmp(x))
def __init__(self, basef, distance = 0.1, offset = None): """ by default the offset is random, with a distance of 0.1 to the old one """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if offset == None: offset = rand(basef.xdim) offset *= distance/norm(offset) self.xopt += offset if isinstance(basef, FunctionEnvironment): self.desiredValue = basef.desiredValue self.f = lambda x: basef.f(x-offset)
def __init__(self, basef, distance=0.1, offset=None): """ by default the offset is random, with a distance of 0.1 to the old one """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if offset == None: offset = rand(basef.xdim) offset *= distance / norm(offset) self.xopt += offset if isinstance(basef, FunctionEnvironment): self.desiredValue = basef.desiredValue self.f = lambda x: basef.f(x - offset)
def __init__(self, basef, rotMat=None): """ by default the rotation matrix is random. """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if rotMat == None: # make a random orthogonal rotation matrix self.M = orth(rand(basef.xdim, basef.xdim)) else: self.M = rotMat if isinstance(basef, FunctionEnvironment): self.desiredValue = basef.desiredValue self.xopt = dot(inv(self.M), self.xopt) self.f = lambda x: basef.f(dot(x, self.M))
def __init__(self, basef, rotMat = None): """ by default the rotation matrix is random. """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if rotMat == None: # make a random orthogonal rotation matrix self.M = orth(rand(basef.xdim, basef.xdim)) else: self.M = rotMat if isinstance(basef, FunctionEnvironment): self.desiredValue = basef.desiredValue self.xopt = dot(inv(self.M), self.xopt) self.f = lambda x: basef.f(dot(x,self.M))
def oppositeFunction(basef): """ the opposite of a function """ if isinstance(basef, FitnessEvaluator): if isinstance(basef, FunctionEnvironment): res = FunctionEnvironment(basef.xdim, basef.xopt) else: res = FitnessEvaluator() res.f = lambda x:-basef.f(x) if not basef.desiredValue is None: res.desiredValue = -basef.desiredValue res.toBeMinimized = not basef.toBeMinimized return res else: return lambda x:-basef(x)
def __init__(self, basef, distance=0.1, offset=None): """ by default the offset is random, with a distance of 0.1 to the old one """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if offset == None: offset = rand(basef.xdim) offset *= distance / norm(offset) self.xopt += offset self.desiredValue = basef.desiredValue self.toBeMinimized = basef.toBeMinimized def tf(x): if isinstance(x, ParameterContainer): x = x.params return basef.f(x - offset) self.f = tf
def __init__(self, basef, rotMat=None): """ by default the rotation matrix is random. """ FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) if rotMat == None: # make a random orthogonal rotation matrix self._M = orth(rand(basef.xdim, basef.xdim)) else: self._M = rotMat self.desiredValue = basef.desiredValue self.toBeMinimized = basef.toBeMinimized self.xopt = dot(inv(self._M), self.xopt) def rf(x): if isinstance(x, ParameterContainer): x = x.params return basef.f(dot(x, self._M)) self.f = rf
def __init__(self, basef, distance=5, penalizationFactor=1.): FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) self.desiredValue = basef.desiredValue self.toBeMinimized = basef.toBeMinimized if basef.penalized: # already OK self.f = basef.f else: if not self.toBeMinimized: penalizationFactor *= -1 def scf(x): if isinstance(x, ParameterContainer): x = x.params return basef.f(x) + penalize(x, distance) * penalizationFactor self.f = scf
def oppositeFunction(basef): """ the opposite of a function """ if isinstance(basef, FitnessEvaluator): if isinstance(basef, FunctionEnvironment): if isinstance(basef, MultiObjectiveFunction): res = MultiObjectiveFunction() else: res = FunctionEnvironment(basef.xdim, basef.xopt) else: res = FitnessEvaluator() res.f = lambda x:-basef.f(x) if not basef.desiredValue is None: res.desiredValue = -basef.desiredValue res.toBeMinimized = not basef.toBeMinimized return res else: return lambda x:-basef(x)
def __init__(self, *args, **kwargs): FunctionEnvironment.__init__(self, *args, **kwargs) self.xopt = (rand(self.xdim) - 0.5) * 9.8
def __init__(self, basef, translate=True, rotate=False, conditioning=None, asymmetry=None, oscillate=False, penalized=0, desiredValue=1e-8, gnoise=None, unoise=None, cnoise=None, sparse=True, ): FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) self._name = basef.__class__.__name__ self.desiredValue = desiredValue self.toBeMinimized = basef.toBeMinimized if self.xdim < 500: sparse = False if sparse: try: from scipy.sparse import csc_matrix except: sparse = False if translate: self.xopt = (rand(self.xdim) - 0.5) * 9.8 if conditioning: prefix = generateDiags(conditioning, self.xdim) if sparse: prefix = csc_matrix(prefix) if rotate: prefix = prefix * sparse_orth(self.xdim) if oscillate or not asymmetry: prefix = sparse_orth(self.xdim) * prefix else: if rotate: prefix = dot(prefix, dense_orth(self.xdim)) if oscillate or not asymmetry: prefix = dot(dense_orth(self.xdim), prefix) elif rotate and asymmetry and not oscillate: if sparse: prefix = sparse_orth(self.xdim) else: prefix = dense_orth(self.xdim) elif sparse: prefix = None else: prefix = eye(self.xdim) if penalized != 0: if self.penalized: penalized = 0 else: self.penalized = True # combine transformations if rotate: if sparse: r = sparse_orth(self.xdim) tmp1 = lambda x: ravel(x * r) else: r = dense_orth(self.xdim) tmp1 = lambda x: dot(x, r) else: tmp1 = lambda x: x if oscillate: tmp2 = lambda x: BBOBTransformationFunction.oscillatify(tmp1(x)) else: tmp2 = tmp1 if asymmetry is not None: tmp3 = lambda x: BBOBTransformationFunction.asymmetrify(tmp2(x), asymmetry) else: tmp3 = tmp2 # noise ntmp = None if gnoise: ntmp = lambda f: f * exp(gnoise * gauss(0, 1)) elif unoise: alpha = 0.49 * (1. / self.xdim) * unoise ntmp = lambda f: f * power(random(), unoise) * max(1, power(1e9 / (f + 1e-99), alpha * random())) elif cnoise: alpha, beta = cnoise ntmp = lambda f: f + alpha * max(0, 1000 * (random() < beta) * gauss(0, 1) / (abs(gauss(0, 1)) + 1e-199)) def noisetrans(f): if ntmp is None or f < 1e-8: return f else: return ntmp(f) + 1.01e-8 if sparse: if prefix is None: tmp4 = lambda x: tmp3(x - self.xopt) else: tmp4 = lambda x: ravel(prefix * tmp3(x - self.xopt)) else: tmp4 = lambda x: dot(prefix, tmp3(x - self.xopt)) self.f = lambda x: (noisetrans(basef.f(tmp4(x))) + penalized * penalize(x))
def __init__(self, xdim=1, a=1, xopt=None): # additional parameter self.a = a FunctionEnvironment.__init__(self, xdim, xopt)
def __init__(self, basef): FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) self.f = lambda x: -basef.f(x)
def __init__(self, *args, **kwargs): FunctionEnvironment.__init__(self, *args, **kwargs) self._w = [power(10, i/(self.xdim-1.)) for i in range(self.xdim)] self._signs = sign(randn(self.xdim))
def __init__(self, *args, **kwargs): FunctionEnvironment.__init__(self, *args, **kwargs) self._as = array([power(self.a, 2*i/(self.xdim-1.)) for i in range(self.xdim)])
def __init__( self, basef, translate=True, rotate=False, conditioning=None, asymmetry=None, oscillate=False, penalized=0, desiredValue=1e-8, gnoise=None, unoise=None, cnoise=None, sparse=True, ): FunctionEnvironment.__init__(self, basef.xdim, basef.xopt) self._name = basef.__class__.__name__ self.desiredValue = desiredValue self.toBeMinimized = basef.toBeMinimized if self.xdim < 500: sparse = False if sparse: try: from scipy.sparse import csc_matrix except: sparse = False if translate: self.xopt = (rand(self.xdim) - 0.5) * 9.8 if conditioning: prefix = generateDiags(conditioning, self.xdim) if sparse: prefix = csc_matrix(prefix) if rotate: prefix = prefix * sparse_orth(self.xdim) if oscillate or not asymmetry: prefix = sparse_orth(self.xdim) * prefix else: if rotate: prefix = dot(prefix, dense_orth(self.xdim)) if oscillate or not asymmetry: prefix = dot(dense_orth(self.xdim), prefix) elif rotate and asymmetry and not oscillate: if sparse: prefix = sparse_orth(self.xdim) else: prefix = dense_orth(self.xdim) elif sparse: prefix = None else: prefix = eye(self.xdim) if penalized != 0: if self.penalized: penalized = 0 else: self.penalized = True # combine transformations if rotate: if sparse: r = sparse_orth(self.xdim) tmp1 = lambda x: ravel(x * r) else: r = dense_orth(self.xdim) tmp1 = lambda x: dot(x, r) else: tmp1 = lambda x: x if oscillate: tmp2 = lambda x: BBOBTransformationFunction.oscillatify(tmp1(x)) else: tmp2 = tmp1 if asymmetry is not None: tmp3 = lambda x: BBOBTransformationFunction.asymmetrify( tmp2(x), asymmetry) else: tmp3 = tmp2 # noise ntmp = None if gnoise: ntmp = lambda f: f * exp(gnoise * gauss(0, 1)) elif unoise: alpha = 0.49 * (1. / self.xdim) * unoise ntmp = lambda f: f * power(random(), unoise) * max( 1, power(1e9 / (f + 1e-99), alpha * random())) elif cnoise: alpha, beta = cnoise ntmp = lambda f: f + alpha * max( 0, 1000 * (random() < beta) * gauss(0, 1) / (abs(gauss(0, 1)) + 1e-199)) def noisetrans(f): if ntmp is None or f < 1e-8: return f else: return ntmp(f) + 1.01e-8 if sparse: if prefix is None: tmp4 = lambda x: tmp3(x - self.xopt) else: tmp4 = lambda x: ravel(prefix * tmp3(x - self.xopt)) else: tmp4 = lambda x: dot(prefix, tmp3(x - self.xopt)) self.f = lambda x: (noisetrans(basef.f(tmp4(x))) + penalized * penalize(x))
def __init__(self, *args, **kwargs): FunctionEnvironment.__init__(self, *args, **kwargs) self._as = array([ power(self.a, 2 * i / (self.xdim - 1.)) for i in range(self.xdim) ])
def __init__(self, *args, **kwargs): FunctionEnvironment.__init__(self, *args, **kwargs) self._w = [power(10, i / (self.xdim - 1.)) for i in range(self.xdim)] self._signs = sign(randn(self.xdim))