def test_rosenbrock(self):
"""Test the rosenbrock benchmark."""
rosenbrock = Utility().get_benchmark('rosenbrock')
fun = rosenbrock.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array2), 0.0)
def test_sphere(self):
"""Test the sphere benchmark."""
sphere = Utility().get_benchmark('sphere')
fun = sphere.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
def test_schwefel222(self):
"""Test the schwefel 222 benchmark."""
schwefel222 = Utility().get_benchmark('schwefel222')
fun = schwefel222.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
def test_schwefel(self):
"""Test the schwefel benchmark."""
schwefel = Utility().get_benchmark('schwefel')
fun = schwefel.function()
self.assertTrue(callable(fun))
self.assertAlmostEqual(fun(self.D, self.array3), 0.0, places=3)
def test_stepint(self):
"""Test the stepint benchmark."""
stepint = Utility().get_benchmark('stepint')
fun = stepint.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array9), 25.0 - 6 * self.D)
def test_rastrigin(self):
"""Test the rastrigin benchmark."""
rastrigin = Utility().get_benchmark('rastrigin')
fun = rastrigin.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
def test_step3(self):
"""Test the step3 benchmark."""
step3 = Utility().get_benchmark('step3')
fun = step3.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
def test_styblinskiTang(self):
"""Test the styblinski tang benchmark."""
styblinskiTang = Utility().get_benchmark('styblinskiTang')
fun = styblinskiTang.function()
self.assertTrue(callable(fun))
self.assertAlmostEqual(fun(2, self.array4), -78.332, places=3)
def test_sumSquares(self):
"""Test the sum squares benchmark."""
sumSquares = Utility().get_benchmark('sumSquares')
fun = sumSquares.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
def test_whitley(self):
"""Test the whitley benchmark."""
whitley = Utility().get_benchmark('whitley')
fun = whitley.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array2), 0.0)
def __init__(self, D, NP, nFES, benchmark):
"""**__init__(self, D, NP, nFES, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension of the problem
self.NP = NP # population size; number of search agents
self.FoodNumber = int(self.NP / 2)
self.Limit = 100
self.Trial = [] # trials
self.Foods = [] # foods
self.Probs = [] # probs
self.nFES = nFES # number of function evaluations
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.FEs = 0
self.Done = False
SolutionABC.FuncEval = staticmethod(self.benchmark.function())
self.Best = SolutionABC(self.D, self.Lower, self.Upper)
def __init__(self, D, NP, nFES, F, CR, benchmark):
r"""**__init__(self, D, NP, nFES, F, CR, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
F {decimal} -- scaling factor
CR {decimal} -- crossover rate
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension of problem
self.Np = NP # population size
self.nFES = nFES # number of function evaluations
self.F = F # scaling factor
self.CR = CR # crossover rate
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
SolutionDE.FuncEval = staticmethod(self.benchmark.function())
self.Population = []
self.bestSolution = SolutionDE(self.D, self.Lower, self.Upper)
def test_ackley(self):
"""Test the ackley benchmark."""
ackley = Utility().get_benchmark('ackley')
fun = ackley.function()
self.assertTrue(callable(fun))
self.assertAlmostEqual(fun(self.D, self.array), 0.0, places=10)
def test_griewank(self):
"""Test the griewank benchmark."""
griewank = Utility().get_benchmark('griewank')
fun = griewank.function()
self.assertTrue(callable(fun))
self.assertEqual(fun(self.D, self.array), 0.0)
class UtilityTestCase(TestCase):
def setUp(self):
self.u = Utility()
def test_get_bad_benchmark_fine(self):
self.assertRaises(TypeError,
lambda: self.u.get_benchmark('hihihihihihihihihi'))
self.assertRaises(TypeError, lambda: self.u.get_benchmark(MyBenchmark))
self.assertRaises(TypeError, lambda: self.u.get_benchmark(NoLimits))
def __init__(self,
D=0,
optType=OptimizationType.MINIMIZATION,
benchmark=None,
Lower=None,
Upper=None,
frepair=limit_repair,
**kwargs):
r"""Initialize task class for optimization.
Arguments:
D (Optional[int]): Number of dimensions.
optType (Optional[OptimizationType]): Set the type of optimization.
benchmark (Union[str, Benchmark]): Problem to solve with optimization.
Lower (Optional[numpy.ndarray]): Lower limits of the problem.
Upper (Optional[numpy.ndarray]): Upper limits of the problem.
frepair (Optional[Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray, Dict[str, Any]], numpy.ndarray]]): Function for reparing individuals components to desired limits.
See Also:
* `func`:NiaPy.util.Utility.__init__`
* `func`:NiaPy.util.Utility.repair`
"""
# dimension of the problem
self.D = D
# set optimization type
self.optType = optType
# set optimization function
self.benchmark = Utility().get_benchmark(
benchmark) if benchmark is not None else None
if self.benchmark is not None:
self.Fun = self.benchmark.function(
) if self.benchmark is not None else None
# set Lower limits
if Lower is not None:
self.Lower = fullArray(Lower, self.D)
elif Lower is None and benchmark is not None:
self.Lower = fullArray(self.benchmark.Lower, self.D)
else:
self.Lower = fullArray(0, self.D)
# set Upper limits
if Upper is not None:
self.Upper = fullArray(Upper, self.D)
elif Upper is None and benchmark is not None:
self.Upper = fullArray(self.benchmark.Upper, self.D)
else:
self.Upper = fullArray(0, self.D)
# set range
self.bRange = self.Upper - self.Lower
# set repair function
self.frepair = frepair
def __init__(self, D, NP, nFES, A, r, F, CR, Qmin, Qmax, benchmark):
r"""**__init__(self, D, NP, nFES, A, r, Qmin, Qmax, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
A {decimal} -- loudness
r {decimal} -- pulse rate
Qmin {decimal} -- minimum frequency
Qmax {decimal } -- maximum frequency
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.A = A # loudness
self.r = r # pulse rate
self.F = F # scaling factor
self.CR = CR # crossover rate
self.Qmin = Qmin # frequency min
self.Qmax = Qmax # frequency max
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.eval_flag = True # evaluations flag
self.Fun = self.benchmark.function()
self.f_min = 0.0 # minimum fitness
self.Lb = [0] * self.D # lower bound
self.Ub = [0] * self.D # upper bound
self.Q = [0] * self.NP # frequency
self.v = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # velocity
self.Sol = [[0 for _i in range(self.D)] for _j in range(
self.NP)] # population of solutions
self.Fitness = [0] * self.NP # fitness
self.best = [0] * self.D # best solution
self.evaluations = 0 # evaluations counter
def __init__(self, D, NP, nFES, C1, C2, w, vMin, vMax, benchmark):
r"""**__init__(self, NP, D, nFES, C1, C2, w, vMin, vMax, benchmark)**.
Arguments:
NP {integer} -- population size
D {integer} -- dimension of problem
nFES {integer} -- number of function evaluations
C1 {decimal} -- cognitive component
C2 {decimal} -- social component
w {decimal} -- inertia weight
vMin {decimal} -- minimal velocity
vMax {decimal} -- maximal velocity
benchmark {object} -- benchmark implementation object
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.NP = NP # population size; number of search agents
self.D = D # dimension of the problem
self.C1 = C1 # cognitive component
self.C2 = C2 # social component
self.w = w # inertia weight
self.vMin = vMin # minimal velocity
self.vMax = vMax # maximal velocity
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.nFES = nFES # number of function evaluations
self.eval_flag = True # evaluations flag
self.evaluations = 0 # evaluations counter
self.Fun = self.benchmark.function()
self.Solution = numpy.zeros(
(self.NP, self.D)) # positions of search agents
self.Velocity = numpy.zeros(
(self.NP, self.D)) # velocities of search agents
self.pBestFitness = numpy.zeros(self.NP) # personal best fitness
self.pBestFitness.fill(float("inf"))
self.pBestSolution = numpy.zeros(
(self.NP, self.D)) # personal best solution
self.gBestFitness = float("inf") # global best fitness
self.gBestSolution = numpy.zeros(self.D) # global best solution
def __init__(self, D, NP, nFES, A, r, F, CR, Qmin, Qmax, benchmark):
self.benchmark = Utility.get_benchmark(benchmark)
self.D = D # dimension
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.A = A # loudness
self.r = r # pulse rate
self.F = F # scaling factor
self.CR = CR # crossover rate
self.Qmin = Qmin # frequency min
self.Qmax = Qmax # frequency max
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Fun = self.benchmark.function()
self.f_min = 0.0 # minimum fitness
self.Lb = [0] * self.D # lower bound
self.Ub = [0] * self.D # upper bound
self.Q = [0] * self.NP # frequency
self.v = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # velocity
self.Sol = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # population of solutions
self.Fitness = [0] * self.NP # fitness
self.best = [0] * self.D # best solution
self.evaluations = 0 # evaluations counter
def __init__(self, D, NP, nFES, benchmark):
self.benchmark = Utility.get_benchmark(benchmark)
self.D = D # dimension of the problem
self.NP = NP # population size; number of search agents
self.nFES = nFES # number of function evaluations
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Fun = self.benchmark.function()
self.Positions = [
[0 for _i in range(self.D)] # positions of search agents
for _j in range(self.NP)
]
self.evaluations = 0 # evaluations counter
# TODO: "-inf" is in the case of maximization problems
self.Alpha_pos = [0] * self.D # init of alpha
self.Alpha_score = float("inf")
self.Beta_pos = [0] * self.D # init of beta
self.Beta_score = float("inf")
self.Delta_pos = [0] * self.D # init of delta
self.Delta_score = float("inf")
def assertBounds(self, bench, lower, upper):
"""Checking the bounds.
Arguments:
bench [Benchmark]: Benchmark to test.
lower [float]: Lower bound.
upper [type]: Upper bound.
Returns:
[fun]: Returns benchmarks evaluation function.
"""
b = Utility().get_benchmark(bench)
self.assertEqual(b.Lower, lower)
self.assertEqual(b.Upper, upper)
return b.function()
def test_expanded_griewank_plus_rosnbrock(self):
fun = Utility().get_benchmark(
'expandedgriewankplusrosenbrock').function()
self.assertTrue(callable(fun))
self.assertAlmostEqual(fun(self.D, [1, 2, 3, 4, 5]),
854123.5271421941,
delta=1e2)
def __init__(self, D, NP, nFES, alpha, betamin, gamma, benchmark):
r"""**__init__(self, D, NP, nFES, alpha, betamin, gamma, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
alpha {decimal} -- alpha parameter
betamin {decimal} -- betamin parameter
gamma {decimal} -- gamma parameter
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension of the problem
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.alpha = alpha # alpha parameter
self.betamin = betamin # beta parameter
self.gamma = gamma # gamma parameter
# sort of fireflies according to fitness values
self.Index = [0] * self.NP
self.Fireflies = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # firefly agents
self.Fireflies_tmp = [[0 for _i in range(self.D)]
for _j in range(self.NP)
] # intermediate population
self.Fitness = [0.0] * self.NP # fitness values
self.Intensity = [0.0] * self.NP # light intensity
self.nbest = [0.0] * self.NP # the best solution found so far
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.fbest = None # the best
self.evaluations = 0
self.eval_flag = True # evaluations flag
self.Fun = self.benchmark.function()
class UtilityTestCase(TestCase):
r"""Test case for testing Utility class.
Date:
April 2019
Author:
Klemen Berkovič
See Also:
* :class:`NiaPy.util.Utility`
"""
def setUp(self):
self.u = Utility()
def test_get_bad_benchmark_fine(self):
self.assertRaises(TypeError, lambda: self.u.get_benchmark('hihihihihihihihihi'))
self.assertRaises(TypeError, lambda: self.u.get_benchmark(MyBenchmark))
self.assertRaises(TypeError, lambda: self.u.get_benchmark(NoLimits))
def __init__(self, D, NP, nFES, p, benchmark):
r"""**__init__(self, D, NP, nFES, p, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
p {decimal} -- probability switch
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.p = p # probability switch
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Fun = self.benchmark.function() # function
self.f_min = 0.0 # minimum fitness
self.Lb = [0] * self.D # lower bound
self.Ub = [0] * self.D # upper bound
self.dS = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # differential
self.Sol = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # population of solutions
self.Fitness = [0] * self.NP # fitness
self.best = [0] * self.D # best solution
self.eval_flag = True # evaluations flag
self.evaluations = 0 # evaluations counter
def __init__(self, D, NP, nFES, F, CR, benchmark):
self.benchmark = Utility.get_benchmark(benchmark)
self.D = D # dimension of problem
self.Np = NP # population size
self.nFES = nFES # number of function evaluations
self.F = F # scaling factor
self.CR = CR # crossover rate
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
SolutionDE.FuncEval = staticmethod(self.benchmark.function())
self.Population = []
self.bestSolution = SolutionDE(self.D, self.Lower, self.Upper)
def __init__(self, D, NP, nFES, benchmark):
r"""**__init__(self, D, NP, nFES, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension of the problem
self.NP = NP # population size; number of search agents
self.nFES = nFES # number of function evaluations
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Fun = self.benchmark.function()
self.Positions = [[0 for _i in range(self.D)] # positions of search agents
for _j in range(self.NP)]
self.eval_flag = True # evaluations flag
self.evaluations = 0 # evaluations counter
self.Alpha_pos = [0] * self.D # init of alpha
self.Alpha_score = float("inf")
self.Beta_pos = [0] * self.D # init of beta
self.Beta_score = float("inf")
self.Delta_pos = [0] * self.D # init of delta
self.Delta_score = float("inf")
def __init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark):
r"""**__init__(self, D, NP, nFES, Ts, Mr, gamma, benchmark)**.
Arguments:
D {integer} -- dimension of problem
NP {integer} -- population size
nFES {integer} -- number of function evaluations
Ts {integer} -- tournament selection
Mr {decimal} -- mutation rate
gamma {decimal} -- minimum frequency
benchmark {object} -- benchmark implementation object
Raises:
TypeError -- Raised when given benchmark function which does not exists.
"""
self.benchmark = Utility().get_benchmark(benchmark)
self.NP = NP # population size; number of search agents
self.D = D # dimension of the problem
self.Ts = Ts # tournament selection
self.Mr = Mr # mutation rate
self.gamma = gamma # minimum frequency
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Population = []
self.nFES = nFES # number of function evaluations
self.FEs = 0 # function evaluations
self.Done = False
Chromosome.FuncEval = staticmethod(self.benchmark.function())
self.Best = Chromosome(self.D, self.Lower, self.Upper)
def __init__(self, D, NP, nFES, p, benchmark):
self.benchmark = Utility().get_benchmark(benchmark)
self.D = D # dimension
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.p = p # probability switch
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.Fun = self.benchmark.function() # function
self.f_min = 0.0 # minimum fitness
self.Lb = [0] * self.D # lower bound
self.Ub = [0] * self.D # upper bound
self.dS = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # differential
self.Sol = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # population of solutions
self.Fitness = [0] * self.NP # fitness
self.best = [0] * self.D # best solution
self.eval_flag = True # evaluations flag
self.evaluations = 0 # evaluations counter
def __init__(self, D, NP, nFES, alpha, betamin, gamma, benchmark):
self.benchmark = Utility.get_benchmark(benchmark)
self.D = D # dimension of the problem
self.NP = NP # population size
self.nFES = nFES # number of function evaluations
self.alpha = alpha # alpha parameter
self.betamin = betamin # beta parameter
self.gamma = gamma # gamma parameter
# sort of fireflies according to fitness value
self.Index = [0] * self.NP
self.Fireflies = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # firefly agents
self.Fireflies_tmp = [[0 for _i in range(self.D)]
for _j in range(self.NP)] # intermediate pop
self.Fitness = [0.0] * self.NP # fitness values
self.Intensity = [0.0] * self.NP # light intensity
self.nbest = [0.0] * self.NP # the best solution found so far
self.Lower = self.benchmark.Lower # lower bound
self.Upper = self.benchmark.Upper # upper bound
self.fbest = None # the best
self.evaluations = 0
self.Fun = self.benchmark.function()
