def test_init_population_individual(self): r"""Test if custom generation initialization works ok.""" a = Algorithm(population_size=10, initialization_function=init_pop_individual, individual_type=Individual) t = Task(problem=MyProblem(dimension=20)) i = Individual(x=np.zeros(t.dimension), task=t) pop, fpop, d = a.init_population(t) for e in pop: self.assertEqual(i, e)
def test_init_population_numpy(self): r"""Test if custom generation initialization works ok.""" a = Algorithm(population_size=10, initialization_function=init_pop_numpy) t = Task(problem=MyProblem(dimension=20)) self.assertTrue( np.array_equal(np.zeros((10, t.dimension)), a.init_population(t)[0]))
def set_parameters(self, **kwargs): r"""Set the algorithm parameters/arguments. See Also * :func:`niapy.algorithms.Algorithm.set_parameters` """ kwargs.pop('population_size', None) Algorithm.set_parameters(self, population_size=1, **kwargs) self.candidates = None
def init_population(self, task): r"""Initialize starting population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]: 1. Initialized population. 2. Initialized populations function/fitness value. 3. Additional arguments: * enable (numpy.ndarray): If solution/individual is enabled. * improve (numpy.ndarray): If solution/individual is improved. * search_range (numpy.ndarray): Search range. * grades (numpy.ndarray): Grade of solution/individual. """ population, fitness, d = Algorithm.init_population(self, task) enable = np.full(self.population_size, True) improve = np.full(self.population_size, True) search_range = np.full((self.population_size, task.dimension), task.range / 2) grades = np.zeros(self.population_size) d.update({ 'enable': enable, 'improve': improve, 'search_range': search_range, 'grades': grades }) return population, fitness, d
def get_parameters(self): d = Algorithm.get_parameters(self) d.update({ 'delta': self.delta, 'neighborhood_function': self.neighborhood_function }) return d
def init_population(self, task): r"""Initialize stating population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]: 1. Initialized population. 2. Initialized populations function/fitness values. 3. Additional arguments: * w_neighbor (numpy.ndarray): Weights neighborhood. * w_foraging (numpy.ndarray): Weights foraging. * induced_speed (numpy.ndarray): Induced speed. * foraging_speed (numpy.ndarray): Foraging speed. See Also: * :func:`niapy.algorithms.algorithm.Algorithm.init_population` """ krill_herd, krill_herd_fitness, d = Algorithm.init_population( self, task) w_neighbor, w_foraging = self.init_weights(task) induced_speed, foraging_speed = np.zeros( self.population_size), np.zeros(self.population_size) d.update({ 'w_neighbor': w_neighbor, 'w_foraging': w_foraging, 'induced_speed': induced_speed, 'foraging_speed': foraging_speed }) return krill_herd, krill_herd_fitness, d
def get_parameters(self): d = Algorithm.get_parameters(self) d.update({ 'alpha': self.alpha, 'gamma': self.gamma, 'rho': self.rho, 'sigma': self.sigma }) return d
def set_parameters(self, population_size=20, alpha=1, beta_min=1, gamma=2, **kwargs): r"""Set the parameters of the algorithm. Args: population_size (Optional[int]): Population size. alpha (Optional[float]): Step size. beta_min (Optional[float]): Minimum value of beta. gamma (Optional[float]): Absorption coefficient. kwargs (Dict[str, Any]): Additional arguments. See Also: * :func:`niapy.algorithms.Algorithm.set_parameters` """ Algorithm.set_parameters(self, population_size=population_size, **kwargs) self.alpha = alpha self.beta_min = beta_min self.gamma = gamma
def get_parameters(self): r"""Get algorithms parameters values. Returns: Dict[str, Any]: See Also * :func:`niapy.algorithms.Algorithm.get_parameters` """ d = Algorithm.get_parameters(self) return d
def get_parameters(self): r"""Get parameters values of the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ d = Algorithm.get_parameters(self) d.update({ 'lifetime': self.lifetime, 'area_limit': self.area_limit, 'local_seeding_changes': self.local_seeding_changes, 'global_seeding_changes': self.global_seeding_changes, 'transfer_rate': self.transfer_rate }) return d
def init_population(self, task): r"""Init population. Args: task (Task): Optimization task Returns: Tuple(numpy.ndarray[MkeSolution], numpy.ndarray[float], Dict[str, Any]]: 1. Initialized solutions 2. Fitness/function values of solution 3. Additional arguments """ pop, fpop, _ = Algorithm.init_population(self, task) for i in self.rng.choice(self.population_size, int(self.population_rate * len(pop)), replace=False): pop[i].monkey_king = True return pop, fpop, {}
def get_parameters(self): r"""Get parameters values of the algorithm. Returns: Dict[str, Any]: Algorithm parameters. See Also: * :func:`niapy.algorithms.Algorithm.get_parameters` """ d = Algorithm.get_parameters(self) d.update({ 'differential_weight': self.differential_weight, 'crossover_probability': self.crossover_probability, 'strategy': self.strategy }) return d
def get_parameters(self): r"""Get parameters values for the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ d = Algorithm.get_parameters(self) d.update({ 'partition': self.partition, 'period': self.period, 'keep': self.keep, 'bar': self.bar, 'np1': self.np1, 'np2': self.np2 }) return d
def get_parameters(self): r"""Get algorithms parameters values. Returns: Dict[str, Any]: See Also * :func:`niapy.algorithms.Algorithm.get_parameters` """ d = Algorithm.get_parameters(self) d.update({ 'delta': self.delta, 'delta_temperature': self.delta_temperature, 'starting_temperature': self.starting_temperature, 'epsilon': self.epsilon }) return d
def get_parameters(self): r"""Get algorithms parameters values. Returns: Dict[str, Any] See Also: * :func:`niapy.algorithms.Algorithm.get_parameters` """ d = Algorithm.get_parameters(self) d.update({ 'fluctuation_coeff': self.fluctuation_coeff, 'population_rate': self.population_rate, 'c': self.c, 'fc': self.fc }) return d
def init_population(self, task): r"""Initialize the starting population. Args: task (Task): Optimization task Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. New population. 2. New population fitness/function values. 3. Additional arguments: * alpha (float): Step size. See Also: * :func:`niapy.algorithms.Algorithm.init_population` """ fireflies, intensity, _ = Algorithm.init_population(self, task) return fireflies, intensity, {'alpha': self.alpha}
def get_parameters(self): r"""Get parameter values for the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ d = Algorithm.get_parameters(self) d.update({ 'N_max': self.N_max, 'V_f': self.V_f, 'D_max': self.D_max, 'C_t': self.C_t, 'W_n': self.W_n, 'W_f': self.W_f, 'd_s': self.d_s, 'nn': self.nn, }) return d
def get_parameters(self): r"""Get parameters values for the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ d = Algorithm.get_parameters(self) d.update({ 'M': d.pop('population_size', self.population_size), 'num_tests': self.num_tests, 'num_searches': self.num_searches, 'num_searches_best': self.num_searches_best, 'bonus1': self.bonus1, 'bonus2': self.bonus2, 'num_enabled': self.num_enabled, 'local_searches': self.local_searches }) return d
def init_population(self, task): r"""Initialize starting population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray[Individual], numpy.ndarray[float], Dict[str, Any]]: 1. Initialized population. 2. Initialized populations function/fitness values. 3. Additional arguments: * ki (int): Number of successful mutations. See Also: * :func:`niapy.algorithms.algorithm.Algorithm.init_population` """ c, fc, d = Algorithm.init_population(self, task) d.update({'ki': 0}) return c, fc, d
def init_population(self, task): r"""Initialize the initial population. Args: task (Task): Optimization task Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. New population. 2. New population fitness/function values. 3. Additional arguments: * velocities (numpy.ndarray[float]): Velocities See Also: * :func:`niapy.algorithms.Algorithm.init_population` """ population, fitness, d = Algorithm.init_population(self, task) velocities = np.zeros((self.population_size, task.dimension)) d.update({'velocities': velocities}) return population, fitness, d
def get_parameters(self): r"""Get parameter values for the algorithm. Returns: Dict[str, Any]: Algorithm parameters. """ d = Algorithm.get_parameters(self) d.update({ 'n_max': self.n_max, 'foraging_speed': self.foraging_speed, 'diffusion_speed': self.diffusion_speed, 'c_t': self.c_t, 'w_neighbor': self.w_neighbor, 'w_foraging': self.w_foraging, 'd_s': self.d_s, 'max_neighbors': self.max_neighbors, 'crossover_rate': self.cr, 'mutation_rate': self.mr }) return d
def init_population(self, task): r"""Initialize the starting population. Args: task (Task): Optimization task Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. New population. 2. New population fitness/function values. 3. Additional arguments: * age (numpy.ndarray[int32]): Age of trees. See Also: * :func:`niapy.algorithms.Algorithm.init_population` """ trees, fitness, _ = Algorithm.init_population(self, task) age = np.zeros(self.population_size, dtype=np.int32) self.dx = np.absolute(task.upper) / 5.0 return trees, fitness, {'age': age}
def init_population(self, task): r"""Initialize the population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. Initialized population. 2. Initialized population function/fitness values. 3. Additional arguments: * k (int): Starting number of rows to include from lower triangular matrix. * c (int): Constant. See Also: * :func:`niapy.algorithms.algorithm.Algorithm.init_population` """ population, fitness, d = Algorithm.init_population(self, task) k, c = int(ceil(self.population_size / task.dimension)), int(ceil(self.c * task.dimension)) d.update({'k': k, 'c': c}) return population, fitness, d
def init_population(self, task): r"""Initialize first population and additional arguments. Args: task (Task): Optimization task Returns: Tuple[numpy.ndarray, numpy.ndarray, dict]: 1. Initialized population 2. Initialized population fitness/function values 3. Dict[str, Any]: * x_best (numpy.ndarray): Initialized populations best positions. * x_best_fitness (numpy.ndarray): Initialized populations best positions function/fitness values. * alpha (numpy.ndarray): * gamma (numpy.ndarray): * theta (numpy.ndarray): * rs (float): distance of search space. See Also: * :func:`niapy.algorithms.algorithm.Algorithm.init_population` * :func:`niapy.algorithms.other.aso.AnarchicSocietyOptimization.init` """ population, population_fitness, d = Algorithm.init_population( self, task) alpha, gamma, theta = self.init(task) x_best, x_best_fitness = self.update_personal_best( population, task.optimization_type.value * population_fitness, np.zeros((self.population_size, task.dimension)), np.full(self.population_size, np.inf)) d.update({ 'x_best': x_best, 'x_best_fitness': x_best_fitness, 'alpha': alpha, 'gamma': gamma, 'theta': theta, 'rs': self.d(task.upper, task.lower) }) return population, population_fitness, d
def setUp(self): self.seed = 1 self.rng = default_rng(self.seed) self.a = Algorithm(seed=self.seed)
class AlgorithmBaseTestCase(TestCase): r"""Test case for testing Algorithm class. Date: April 2019 Author: Klemen Berkovič Attributes: seed (int): Starting seed of random generator. rng (numpy.random.Generator): Random generator. a (Algorithm): Algorithm to use for testing. See Also: * :class:`niapy.algorithms.Individual` """ def setUp(self): self.seed = 1 self.rng = default_rng(self.seed) self.a = Algorithm(seed=self.seed) def test_algorithm_info(self): r"""Check if method works fine.""" i = Algorithm.info() self.assertIsNotNone(i) def test_algorithm_getParameters(self): r"""Check if method works fine.""" algo = Algorithm() params = algo.get_parameters() self.assertIsNotNone(params) def test_init_population_numpy(self): r"""Test if custom generation initialization works ok.""" a = Algorithm(population_size=10, initialization_function=init_pop_numpy) t = Task(problem=MyProblem(dimension=20)) self.assertTrue(np.array_equal(np.zeros((10, t.dimension)), a.init_population(t)[0])) def test_init_population_individual(self): r"""Test if custom generation initialization works ok.""" a = Algorithm(population_size=10, initialization_function=init_pop_individual, individual_type=Individual) t = Task(problem=MyProblem(dimension=20)) i = Individual(x=np.zeros(t.dimension), task=t) pop, fpop, d = a.init_population(t) for e in pop: self.assertEqual(i, e) def test_set_parameters(self): self.a.set_parameters(t=None, a=20) self.assertRaises(AttributeError, lambda: self.assertEqual(self.a.a, None)) def test_integers(self): o = self.a.integers(low=10, high=20, size=[10, 10]) self.assertEqual(o.shape, (10, 10)) self.assertTrue(np.array_equal(self.rng.integers(10, 20, (10, 10)), o)) o = self.a.integers(low=10, high=20, size=(10, 5)) self.assertEqual(o.shape, (10, 5)) self.assertTrue(np.array_equal(self.rng.integers(10, 20, (10, 5)), o)) o = self.a.integers(low=10, high=20, size=10) self.assertEqual(o.shape, (10,)) self.assertTrue(np.array_equal(self.rng.integers(10, 20, 10), o)) def test_standard_normal(self): a = self.a.standard_normal([1, 2]) self.assertEqual(a.shape, (1, 2)) self.assertTrue(np.array_equal(self.rng.standard_normal((1, 2)), a)) a = self.a.standard_normal(1) self.assertEqual(len(a), 1) self.assertTrue(np.array_equal(self.rng.standard_normal(1), a)) a = self.a.standard_normal(2) self.assertEqual(len(a), 2) self.assertTrue(np.array_equal(self.rng.standard_normal(2), a)) a = self.a.standard_normal() self.assertIsInstance(a, float) self.assertTrue(np.array_equal(self.rng.standard_normal(), a)) def test_uniform(self): a = self.a.uniform(-10, 10, [10, 10]) self.assertEqual(a.shape, (10, 10)) self.assertTrue(np.array_equal(self.rng.uniform(-10, 10, (10, 10)), a)) a = self.a.uniform(4, 10, (4, 10)) self.assertEqual(len(a), 4) self.assertEqual(len(a[0]), 10) self.assertTrue(np.array_equal(self.rng.uniform(4, 10, (4, 10)), a)) a = self.a.uniform(1, 4, 2) self.assertEqual(len(a), 2) self.assertTrue(np.array_equal(self.rng.uniform(1, 4, 2), a)) a = self.a.uniform(10, 100) self.assertIsInstance(a, float) self.assertEqual(self.rng.uniform(10, 100), a) def test_normal(self): a = self.a.normal(-10, 10, [10, 10]) self.assertEqual(a.shape, (10, 10)) self.assertTrue(np.array_equal(self.rng.normal(-10, 10, (10, 10)), a)) a = self.a.normal(4, 10, (4, 10)) self.assertEqual(len(a), 4) self.assertEqual(len(a[0]), 10) self.assertTrue(np.array_equal(self.rng.normal(4, 10, (4, 10)), a)) a = self.a.normal(1, 4, 2) self.assertEqual(len(a), 2) self.assertTrue(np.array_equal(self.rng.normal(1, 4, 2), a)) a = self.a.normal(10, 100) self.assertIsInstance(a, float) self.assertEqual(self.rng.normal(10, 100), a)
def test_algorithm_info(self): r"""Check if method works fine.""" i = Algorithm.info() self.assertIsNotNone(i)
def test_algorithm_getParameters(self): r"""Check if method works fine.""" algo = Algorithm() params = algo.get_parameters() self.assertIsNotNone(params)