def test_BA_evals_fine(self): task = StoppingTask(D=10, nFES=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(NP=25) algo.runTask(task) evals = task.evals() self.assertEqual(1000, evals)
def test_BA_iters_to_fes(self): task = Task(D=10, nGEN=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(task=task, NP=10) algo.run() evals = algo.task.evals() self.assertEqual(evals, 10010)
def test_BA_iters_fine(self): task = StoppingTask(D=10, nGEN=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(NP=25) algo.runTask(task) iters = task.iters() self.assertEqual(1000, iters)
def test_BA_iters_to_fes(self): task = StoppingTask(D=10, nGEN=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(NP=10) algo.runTask(task) evals = task.evals() self.assertEqual(10000, evals)
def test_BA_evals_fine(self): task = Task(D=10, nFES=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(task=task, NP=25) algo.run() evals = algo.task.evals() self.assertEqual(evals, 1000)
def test_BA_iters_fine(self): task = Task(D=10, nGEN=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(task=task, NP=25) algo.run() iters = algo.task.iters() self.assertEqual(iters, 1000)
def optimize(bench, algo): average_mfo = 0 average_de = 0 average_abc = 0 average_pso = 0 average_ba = 0 average_fa = 0 average_ga = 0 for i in np.arange(epoch): mfo = MothFlameOptimizer(D=dim, NP=pop, nGEN=maxIter, benchmark=bench) de = DifferentialEvolution(D=dim, NP=pop, nGEN=maxIter, benchmark=bench) abc = ArtificialBeeColonyAlgorithm(D=dim, NP=pop, nFES=maxIter, benchmark=bench) pso = ParticleSwarmAlgorithm(D=dim, NP=pop, nGEN=maxIter, benchmark=bench) ba = BatAlgorithm(D=dim, NP=pop, nFES=maxIter, benchmark=bench) fa = FireflyAlgorithm(D=dim, NP=pop, nFES=maxIter, benchmark=bench) ga = GeneticAlgorithm(D=dim, NP=pop, nFES=maxIter, benchmark=bench) gen, best_de = de.run() gen, best_mfo = mfo.run() gen, best_abc = abc.run() gen, best_pso = pso.run() gen, best_ba = ba.run() gen, best_fa = fa.run() gen, best_ga = ga.run() average_mfo += best_de / epoch average_de += best_mfo / epoch average_abc += best_abc / epoch average_pso += best_pso / epoch average_ba += best_ba / epoch average_fa += best_fa / epoch average_ga += best_ga / epoch print(algo, ': DE Average of Bests over', epoch, 'run: ', average_de) print(algo, ': MFO Average of Bests over', epoch, 'run: ', average_mfo) print(algo, ': ABC Average of Bests over', epoch, 'run: ', average_abc) print(algo, ': PSO Average of Bests over', epoch, 'run: ', average_pso) print(algo, ': BA Average of Bests over', epoch, 'run: ', average_ba) print(algo, ': FA Average of Bests over', epoch, 'run: ', average_fa) print(algo, ': GA Average of Bests over', epoch, 'run: ', average_ga) return [ average_de, average_mfo, average_abc, average_pso, average_ba, average_fa, average_ga ]
class BATestCase(TestCase): def setUp(self): self.ba_custom = BatAlgorithm(10, 20, 10000, 0.5, 0.5, 0.0, 2.0, MyBenchmark()) self.ba_griewank = BatAlgorithm(10, 40, 10000, 0.5, 0.5, 0.0, 2.0, 'griewank') def test_custom_works_fine(self): self.assertTrue(self.ba_custom.run()) def test_griewank_works_fine(self): self.assertTrue(self.ba_griewank.run())
def setParameters(self, F=0.50, CR=0.90, CrossMutt=CrossBest1, **ukwargs): r"""Set core parameters of HybridBatAlgorithm algorithm. Arguments: F (Optional[float]): Scaling factor. CR (Optional[float]): Crossover. See Also: * :func:`NiaPy.algorithms.basic.BatAlgorithm.setParameters` """ BatAlgorithm.setParameters(self, **ukwargs) self.F, self.CR, self.CrossMutt = F, CR, CrossMutt
def setParameters(self, F=0.78, CR=0.35, CrossMutt=CrossBest1, **ukwargs): r"""**__init__(self, D, NP, nFES, A, r, Qmin, Qmax, benchmark)**. **Arguments:** F {decimal} -- scaling factor CR {decimal} -- crossover """ BatAlgorithm.setParameters(self, **ukwargs) self.F, self.CR, self.CrossMutt = F, CR, CrossMutt if ukwargs: logger.info('Unused arguments: %s' % (ukwargs))
def __get_algorithm(algorithm, population_size, random_state): if isinstance(algorithm, str): if algorithm not in SUPPORTED_ALGORITHMS: raise ValueError( f'"{algorithm}" is not in supported algorithms: {", ".join(SUPPORTED_ALGORITHMS)}' ) algorithm_obj = None if algorithm == 'fa': algorithm_obj = FireflyAlgorithm(seed=random_state) algorithm_obj.setParameters(alpha=1, betamin=1, gamma=2) elif algorithm == 'ba': algorithm_obj = BatAlgorithm(seed=random_state) algorithm_obj.setParameters(A=0.9, r=0.1, Qmin=0.0, Qmax=2.0) elif algorithm == 'hba': algorithm_obj = HybridBatAlgorithm(seed=random_state) algorithm_obj.setParameters(A=0.9, r=0.1, Qmin=0.0, Qmax=2.0) elif algorithm == 'hsaba': algorithm_obj = HybridSelfAdaptiveBatAlgorithm( seed=random_state) algorithm_obj.setParameters(A=0.9, r=0.1, Qmin=0.0, Qmax=2.0) elif algorithm == 'gwo': algorithm_obj = GreyWolfOptimizer(seed=random_state) algorithm_obj.setParameters(NP=population_size) return algorithm_obj return algorithm
def setUp(self): self.ba_custom = BatAlgorithm(D=10, NP=20, nFES=1000, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark=MyBenchmark()) self.ba_griewank = BatAlgorithm(NP=10, D=40, nFES=1000, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark='griewank')
def __init__(self, **kwargs): r"""Initialize BA feature selection algorithm. """ self._params = dict(A=ParameterDefinition(MinMax(0.5, 1.0), param_type=float), r=ParameterDefinition(MinMax(0.0, 0.5), param_type=float), Qmin=ParameterDefinition(MinMax(0.0, 1.0), param_type=float), Qmax=ParameterDefinition(MinMax(1.0, 2.0), param_type=float)) self.__ba = BA(NP=10)
def __init__(self, algorithm_name, objective, maxfeval, population=30): super().__init__(algorithm_name, objective, maxfeval) self.algorithm_name = algorithm_name self.algo = None #this is the suggest function from hyperopt if algorithm_name not in __all__: raise Exception('NiaPy does not have algorithm :' + str(algorithm_name)) elif self.algorithm_name == 'NiaPyABC': self.algo = ArtificialBeeColonyAlgorithm(NP=population, Limit=100) elif self.algorithm_name == 'NiaPyBat': self.algo = BatAlgorithm(NP=population) elif self.algorithm_name == 'NiaPyCuckooSearch': self.algo = CuckooSearch(N=population, pa=0.2, alpha=0.5) elif self.algorithm_name == 'NiaPyDifferentialEvolution': self.algo = DifferentialEvolution(NP=population, F=1, CR=0.8) elif self.algorithm_name == 'NiaPyFireflyAlgorithm': self.algo = FireflyAlgorithm(NP=population, alpha=0.5, betamin=0.2, gamma=1.0) elif self.algorithm_name == 'NiaPyGeneticAlgorithm': self.algo = FireflyAlgorithm(NP=population, Crossover=UniformCrossover, Mutation=UniformMutation, Cr=0.45, Mr=0.9) elif self.algorithm_name == 'NiaPyGWO': self.algo = GreyWolfOptimizer(NP=population) # config elif self.algorithm_name == 'NiaPyNelderMead': self.algo = NelderMeadMethod() # config elif self.algorithm_name == 'NiaPyPSO': self.algo = ParticleSwarmAlgorithm(NP=population, C1=2, C2=2, w=0.9, vMin=-1.5, vMax=1.5) # config # config # config elif self.algorithm_name == 'NiaPySimulatedAnnealing': self.algo = SimulatedAnnealing(coolingMethod=coolLinear)
def typeParameters(): r"""Get dictionary with functions for checking values of parameters. Returns: Dict[str, Callable]: * F (Callable[[Union[int, float]], bool]): TODO * CR (Callable[[float], bool]): TODO """ d = BatAlgorithm.typeParameters() d['F'] = lambda x: isinstance(x, (int, float)) and x > 0 d['CR'] = lambda x: isinstance(x, float) and 0 <= x <= 1 return d
def setParameters(self, NP=40, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, F=0.78, CR=0.35, CrossMutt=CrossBest1, **ukwargs): r"""Set core parameters of HybridBatAlgorithm algorithm. Arguments: F (Optional[float]): Scaling factor. CR (Optional[float]): Crossover. See Also: * :func:`NiaPy.algorithms.basic.BatAlgorithm.setParameters` """ BatAlgorithm.setParameters(self, **ukwargs) self.A, self.r, self.Qmin, self.Qmax, self.F, self.CR, self.CrossMutt = A, r, Qmin, Qmax, F, CR, CrossMutt if ukwargs: logger.info('Unused arguments: %s' % (ukwargs))
class BATestCase(TestCase): def setUp(self): self.ba_custom = BatAlgorithm(D=10, NP=20, nFES=1000, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark=MyBenchmark()) self.ba_griewank = BatAlgorithm(NP=10, D=40, nFES=1000, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark='griewank') def test_custom_works_fine(self): self.assertTrue(self.ba_custom.run()) def test_griewank_works_fine(self): self.assertTrue(self.ba_griewank.run())
def test_parameter_type(self): d = BatAlgorithm.typeParameters() self.assertTrue(d['Qmax'](10)) self.assertTrue(d['Qmin'](10)) self.assertTrue(d['r'](10)) self.assertFalse(d['r'](-10)) self.assertFalse(d['r'](0)) self.assertFalse(d['A'](0)) self.assertFalse(d['A'](-19)) self.assertTrue(d['NP'](10)) self.assertFalse(d['NP'](-10)) self.assertFalse(d['NP'](0)) self.assertTrue(d['A'](10)) self.assertFalse(d['Qmin'](None)) self.assertFalse(d['Qmax'](None))
def initPopulation(self, task): r"""Initialize starting population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. Initialized population. 2. Initialized populations fitness/function values. 3. Additional arguments: * v (numpy.ndarray[float]): TODO """ Sol, Fitness, _ = BatAlgorithm.initPopulation(self, task) v = full([self.NP, task.D], 0.0) return Sol, Fitness, {'v': v}
def typeParameters(): r"""Get dictionary with functions for checking values of parameters. Returns: Dict[str, Callable]: * F (Callable[[Union[int, float]], bool]): Scaling factor. * CR (Callable[[float], bool]): Crossover probability. See Also: * :func:`NiaPy.algorithms.basic.BatAlgorithm.typeParameters` """ d = BatAlgorithm.typeParameters() d.update({ 'F': lambda x: isinstance(x, (int, float)) and x > 0, 'CR': lambda x: isinstance(x, float) and 0 <= x <= 1 }) return d
# encoding=utf8 # This is temporary fix to import module from parent folder # It will be removed when package is published on PyPI import sys sys.path.append('../') # End of fix from NiaPy.algorithms.basic import BatAlgorithm from NiaPy.util import StoppingTask, OptimizationType from NiaPy.benchmarks import Sphere # we will run Bat Algorithm for 5 independent runs for i in range(5): task = StoppingTask(D=10, nGEN=1000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = BatAlgorithm(NP=40, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0) best = algo.run(task=task) print('%s -> %s' % (best[0], best[1]))
def evaluate(D, sol): val = 0.0 for i in range(D): val = val + sol[i] * sol[i] return val return evaluate # example using custom benchmark "MyBenchmark" logger.info('Running with custom MyBenchmark...') for i in range(10): Algorithm = BatAlgorithm(D=10, NP=40, nFES=10000, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark=MyBenchmark()) Best = Algorithm.run() logger.info(Best) # example using predifined benchmark function # available benchmarks are: # - griewank # - rastrigin # - rosenbrock # - sphere logger.info('Running with default Griewank benchmark...') griewank = Griewank()
class BatAlgorithm(FeatureSelectionAlgorithm): r"""Implementation of feature selection using BA algorithm. Date: 2020 Author: Luka Pečnik Reference: The implementation is adapted according to the following article: D. Fister, I. Fister, T. Jagrič, I. Fister Jr., J. Brest. A novel self-adaptive differential evolution for feature selection using threshold mechanism . In: Proceedings of the 2018 IEEE Symposium on Computational Intelligence (SSCI 2018), pp. 17-24, 2018. Reference URL: http://iztok-jr-fister.eu/static/publications/236.pdf License: MIT See Also: * :class:`niaaml.preprocessing.feature_selection.feature_selection_algorithm.FeatureSelectionAlgorithm` """ Name = 'Bat Algorithm' def __init__(self, **kwargs): r"""Initialize BA feature selection algorithm. """ self._params = dict(A=ParameterDefinition(MinMax(0.5, 1.0), param_type=float), r=ParameterDefinition(MinMax(0.0, 0.5), param_type=float), Qmin=ParameterDefinition(MinMax(0.0, 1.0), param_type=float), Qmax=ParameterDefinition(MinMax(1.0, 2.0), param_type=float)) self.__ba = BA(NP=10) def set_parameters(self, **kwargs): r"""Set the parameters/arguments of the algorithm. """ kwargs['NP'] = self.__ba.NP self.__ba.setParameters(**kwargs) def __final_output(self, sol): r"""Calculate final array of features. Arguments: sol (numpy.ndarray[float]): Individual of population/ possible solution. Returns: numpy.ndarray[bool]: Mask of selected features. """ selected = numpy.ones(sol.shape[0] - 1, dtype=bool) threshold = sol[sol.shape[0] - 1] for i in range(sol.shape[0] - 1): if sol[i] < threshold: selected[i] = False return selected def select_features(self, x, y, **kwargs): r"""Perform the feature selection process. Arguments: x (pandas.core.frame.DataFrame): Array of original features. y (pandas.core.series.Series) Expected classifier results. Returns: pandas.core.frame.DataFrame: Mask of selected features. """ num_features = x.shape[1] benchmark = _FeatureSelectionThresholdBenchmark(x, y) task = StoppingTask(D=num_features + 1, nFES=1000, benchmark=benchmark) best = self.__ba.run(task) return self.__final_output(benchmark.get_best_solution()) def to_string(self): r"""User friendly representation of the object. Returns: str: User friendly representation of the object. """ return FeatureSelectionAlgorithm.to_string(self).format( name=self.Name, args=self._parameters_to_string(self.__ba.getParameters()))
def typeParameters(): d = BatAlgorithm.typeParameters() d['F'] = lambda x: isinstance(x, (int, float)) and x > 0 d['CR'] = lambda x: isinstance(x, float) and 0 <= x <= 1 return d
def setUp(self): self.ba_custom = BatAlgorithm(10, 20, 10000, 0.5, 0.5, 0.0, 2.0, MyBenchmark()) self.ba_griewank = BatAlgorithm(10, 40, 10000, 0.5, 0.5, 0.0, 2.0, 'griewank')
self.Upper = 11 def function(self): def evaluate(D, sol): val = 0.0 for i in range(D): val = val + sol[i] * sol[i] return val return evaluate # example using custom benchmark "MyBenchmark" logger.info('Running with custom MyBenchmark...') for i in range(10): Algorithm = BatAlgorithm(10, 40, 10000, 0.5, 0.5, 0.0, 2.0, MyBenchmark()) Best = Algorithm.run() logger.info(Best) # example using predifined benchmark function # available benchmarks are: # - griewank # - rastrigin # - rosenbrock # - sphere logger.info('Running with default Griewank benchmark...') griewank = Griewank() for i in range(10):
def setParameters(self, **kwargs): BatAlgorithm.setParameters(self, **kwargs) self.__setParams(**kwargs)
def __init__(self, **kwargs): BatAlgorithm.__init__(self, name='HybridBatAlgorithm', sName='HBA', **kwargs)
def test_custom_works_fine(self): ba_custom = BatAlgorithm(D=self.D, NP=20, nFES=self.nFES, nGEN=self.nGEN, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark=MyBenchmark(), seed=self.seed) ba_customc = BatAlgorithm(D=self.D, NP=20, nFES=self.nFES, nGEN=self.nGEN, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark=MyBenchmark(), seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, ba_custom, ba_customc)
def test_griewank_works_fine(self): ba_griewank = BatAlgorithm(NP=10, D=self.D, nFES=self.nFES, nGEN=self.nGEN, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark='griewank', seed=self.seed) ba_griewankc = BatAlgorithm(NP=10, D=self.D, nFES=self.nFES, nGEN=self.nGEN, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, benchmark='griewank', seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, ba_griewank, ba_griewankc)