class GWOTestCase(TestCase): def setUp(self): self.gwo_custom = GreyWolfOptimizer(10, 20, 1000, MyBenchmark()) self.gwo_sphere = GreyWolfOptimizer(10, 20, 1000, 'sphere') def test_custom_works_fine(self): self.assertTrue(self.gwo_custom.run()) def test_sphere_works_fine(self): self.assertTrue(self.gwo_sphere.run())
class GWOTestCase(TestCase): def setUp(self): self.gwo_custom = GreyWolfOptimizer(D=10, NP=20, nFES=1000, benchmark=MyBenchmark()) self.gwo_sphere = GreyWolfOptimizer(NP=10, D=20, nFES=1000, benchmark='sphere') def test_custom_works_fine(self): self.assertTrue(self.gwo_custom.run()) def test_sphere_works_fine(self): self.assertTrue(self.gwo_sphere.run())
def test_griewank_works_fine(self): gwo_griewank = GreyWolfOptimizer(NP=10, D=self.D, nFES=self.nFES, nGEN=self.nGEN, benchmark='griewank', seed=self.seed) gwo_griewankc = GreyWolfOptimizer(NP=10, D=self.D, nFES=self.nFES, nGEN=self.nGEN, benchmark='griewank', seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, gwo_griewank, gwo_griewankc)
def test_custom_works_fine(self): gwo_custom = GreyWolfOptimizer(D=self.D, NP=20, nFES=self.nFES, nGEN=self.nGEN, benchmark=MyBenchmark(), seed=self.seed) gwo_customc = GreyWolfOptimizer(D=self.D, NP=20, nFES=self.nFES, nGEN=self.nGEN, benchmark=MyBenchmark(), seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, gwo_custom, gwo_customc)
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 test_get_algorithm_fine(self): algorithm = MyCustomAlgorithm() gwo = GreyWolfOptimizer() self.assertEqual(algorithm, self.algorithm_utility.get_algorithm(algorithm)) self.assertEqual(gwo, self.algorithm_utility.get_algorithm(gwo)) self.assertTrue( isinstance( self.algorithm_utility.get_algorithm("GreyWolfOptimizer"), GreyWolfOptimizer))
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)
# 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 GreyWolfOptimizer from NiaPy.util import StoppingTask, OptimizationType from NiaPy.benchmarks import Sphere # we will run Grey Wolf Optimizer for 5 independent runs for i in range(5): task = StoppingTask(D=10, nFES=10000, optType=OptimizationType.MINIMIZATION, benchmark=Sphere()) algo = GreyWolfOptimizer(NP=40) best = algo.run(task=task) print(best)
def test_griewank_works_fine(self): gwo_griewank = GreyWolfOptimizer(NP=10, seed=self.seed) gwo_griewankc = GreyWolfOptimizer(NP=10, seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, gwo_griewank, gwo_griewankc)
def test_custom_works_fine(self): gwo_custom = GreyWolfOptimizer(NP=20, seed=self.seed) gwo_customc = GreyWolfOptimizer(NP=20, seed=self.seed) AlgorithmTestCase.algorithm_run_test(self, gwo_custom, gwo_customc, MyBenchmark())
val = 0.0 for i in range(D): val += sol[i]**2 return val return evaluate # custom initialization population function def MyInit(task, NP, rnd=rand, **kwargs): pop = 0.2 + rnd.rand(NP, task.D) * task.bRange fpop = apply_along_axis(task.eval, 1, pop) return pop, fpop # we will run 10 repetitions of Grey Wolf Optimizer against our custom MyBenchmark benchmark function for i in range(10): task = StoppingTask(D=20, nGEN=100, optType=OptimizationType.MINIMIZATION, benchmark=MyBenchmark()) # parameter is population size algo = GreyWolfOptimizer(NP=20, InitPopFunc=MyInit) # running algorithm returns best found minimum best = algo.run(task) # printing best minimum print(best[-1])
def setUp(self): self.gwo_custom = GreyWolfOptimizer(D=10, NP=20, nFES=1000, benchmark=MyBenchmark()) self.gwo_sphere = GreyWolfOptimizer(NP=10, D=20, nFES=1000, benchmark='sphere')
class GreyWolfOptimizer(FeatureSelectionAlgorithm): r"""Implementation of feature selection using GWO 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 = 'Grey Wolf Optimizer' def __init__(self, **kwargs): r"""Initialize GWO feature selection algorithm. """ super(GreyWolfOptimizer, self).__init__() self.__gwo = GWO(NP=10) 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: numpy.ndarray[bool]: 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.__gwo.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.__gwo.getParameters()))
logging.basicConfig() logger = logging.getLogger('examples') logger.setLevel('INFO') # For reproducive results random.seed(1234) class MyBenchmark(object): def __init__(self): self.Lower = -11 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 for i in range(10): Algorithm = GreyWolfOptimizer(D=10, NP=20, nFES=10000, benchmark=MyBenchmark()) Best = Algorithm.run() logger.info(Best)
def __init__(self, **kwargs): r"""Initialize GWO feature selection algorithm. """ super(GreyWolfOptimizer, self).__init__() self.__gwo = GWO(NP=10)
Ackley, Griewank, Sphere, HappyCat ) """Example demonstrating the use of NiaPy Runner.""" runner = Runner( D=40, nFES=100, nRuns=2, useAlgorithms=[ GreyWolfOptimizer(), "FlowerPollinationAlgorithm", ParticleSwarmAlgorithm(), "HybridBatAlgorithm", "SimulatedAnnealing", "CuckooSearch"], useBenchmarks=[ Ackley(), Griewank(), Sphere(), HappyCat(), "rastrigin"] ) print(runner.run(verbose=True))
def __init__(self): Benchmark.__init__(self, -10, 10) def function(self): def evaluate(D, sol): val = 0.0 for i in range(D): val += sol[i]**2 return val return evaluate runner = Runner(D=40, nFES=100, nRuns=2, useAlgorithms=[ GreyWolfOptimizer(), "FlowerPollinationAlgorithm", ParticleSwarmAlgorithm(), "HybridBatAlgorithm", "SimulatedAnnealing", "CuckooSearch" ], useBenchmarks=[ Ackley(), Griewank(), Sphere(), HappyCat(), "rastrigin", MyBenchmark() ]) runner.run(export='json', verbose=True)
import logging from NiaPy.algorithms.basic import GreyWolfOptimizer logging.basicConfig() logger = logging.getLogger('examples') logger.setLevel('INFO') class MyBenchmark(object): def __init__(self): self.Lower = -11 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 for i in range(10): Algorithm = GreyWolfOptimizer(10, 20, 10000, MyBenchmark()) Best = Algorithm.run() logger.info(Best)
# 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 GreyWolfOptimizer from NiaPy.task import StoppingTask # we will run 10 repetitions of Grey Wolf Optimizer against Pinter benchmark function for i in range(10): task = StoppingTask(D=10, nFES=1000, benchmark='pinter') algorithm = GreyWolfOptimizer(NP=20) best = algorithm.run(task) print(best)
def setUp(self): self.gwo_custom = GreyWolfOptimizer(10, 20, 1000, MyBenchmark()) self.gwo_sphere = GreyWolfOptimizer(10, 20, 1000, 'sphere')
from NiaPy.algorithms.basic import GreyWolfOptimizer # we will run 10 repetitions of Grey Wolf Optimizer against Pinter benchmark function for i in range(10): # first paradeFordPrefect # meter takes dimension of problem # second parameter is population size # third parameter takes the number of function evaluations # fourth parameter is benchmark function algorithm = GreyWolfOptimizer(10, 20, 10000, 'pinter') # running algorithm returns best found minimum best = algorithm.run() # printing best minimum print(best)
# End of fix import logging from NiaPy.algorithms.basic import GreyWolfOptimizer logging.basicConfig() logger = logging.getLogger('examples') logger.setLevel('INFO') class MyBenchmark(object): def __init__(self): self.Lower = -11 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 for i in range(10): Algorithm = GreyWolfOptimizer(10, 20, 10000, 'sphere') Best = Algorithm.run() logger.info(Best)
# 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 GreyWolfOptimizer from NiaPy.benchmarks import Pinter # initialize Pinter benchamrk with custom bound pinterCustom = Pinter(-5, 5) # we will run 10 repetitions of Grey Wolf Optimizer against Pinter benchmark function for i in range(10): # first parameter takes dimension of problem # second parameter is population size # third parameter takes the number of function evaluations # fourth parameter is benchmark function algorithm = GreyWolfOptimizer(10, 20, 10000, pinterCustom) # running algorithm returns best found minimum best = algorithm.run() # printing best minimum print(best)