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()