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, 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, 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 __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, *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, 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, 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))
