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)
