def initPopulation(self, task):
r"""Initialize the starting population.
Parameters:
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:
* A (float): Loudness.
* S (numpy.ndarray): TODO
* Q (numpy.ndarray[float]): TODO
* v (numpy.ndarray[float]): TODO
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
Sol, Fitness, d = Algorithm.initPopulation(self, task)
A, S, Q, v = np.full(self.NP,
self.A), np.full([self.NP, task.D], 0.0), np.full(
self.NP, 0.0), np.full([self.NP, task.D], 0.0)
d.update({'A': A, 'S': S, 'Q': Q, 'v': v})
return Sol, Fitness, d
def test_init_population_numpy_fine(self):
r"""Test if custome generation initialization works ok."""
a = Algorithm(NP=10, InitPopFunc=init_pop_numpy)
t = Task(D=20, benchmark=MyBenchmark())
self.assertTrue(
array_equal(full((10, t.D), 0.0),
a.initPopulation(t)[0]))
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 population function/fitness values
3. Additional arguments:
* best_flames (numpy.ndarray): Best individuals
* best_flame_fitness (numpy.ndarray): Best individuals fitness/function values
* previous_population (numpy.ndarray): Previous population
* previous_fitness (numpy.ndarray[float]): Previous population fitness/function values
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
"""
moth_pos, moth_fitness, d = Algorithm.initPopulation(self, task)
# Create best population
indexes = argsort(moth_fitness)
best_flames, best_flame_fitness = moth_pos[indexes], moth_fitness[
indexes]
# Init previous population
previous_population, previous_fitness = zeros(
(self.NP, task.D)), zeros(self.NP)
d.update({
'best_flames': best_flames,
'best_flame_fitness': best_flame_fitness,
'previous_population': previous_population,
'previous_fitness': previous_fitness
})
return moth_pos, moth_fitness, d
def initPopulation(self, task):
r"""Initialize firt herd/population.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
1. Initialized herd/population.
2. Initialized herd/populations function/fitness values.
3. Additional arguments:
* KHo (): --
* KHo_f (): --
* N (): --
* F (): --
* Dt (): --
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
KH, KH_f, d = Algorithm.initPopulation(self, task)
KHo, KHo_f = full([self.NP, task.D], task.optType.value * inf), full(self.NP, task.optType.value * inf)
N, F, Dt = full(self.NP, .0), full(self.NP, .0), mean(task.bcRange()) / 2
d.update({'KHo': KHo, 'KHo_f': KHo_f, 'N': N, 'F': F, 'Dt': Dt})
return KH, KH_f, d
def initPopulation(self, task):
r"""Initialize 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:
* A (): TODO
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
pop, fpop, d = Algorithm.initPopulation(self, task)
A, A_f, B, B_f, D, D_f = None, task.optType.value * inf, None, task.optType.value * inf, None, task.optType.value * inf
for i, f in enumerate(fpop):
if f < A_f:
A, A_f = pop[i], f
elif A_f < f < B_f:
B, B_f = pop[i], f
elif B_f < f < D_f:
D, D_f = pop[i], f
d.update({'A': A, 'A_f': A_f, 'B': B, 'B_f': B_f, 'D': D, 'D_f': D_f})
return pop, fpop, d
def initPopulation(self, task):
r"""Initialize first population and additional arguments.
Args:
task (Task): Optimization task
Returns:
Tuple[numpy.ndarray, numpy.ndarray[float], dict]:
1. Initialized population
2. Initialized population fitness/function values
3. Dict[str, Union[float, int, array[Union[float, int]]]:
* Xpb (numpy.ndarray): Initialized populations best positions.
* Xpb_f (numpy.ndarray[float]): Initialized populations best positions function/fitness values.
* alpha (numpy.ndarray[float]):
* gamma (numpy.ndarray[float]):
* theta (numpy.ndarray[float]):
* rs (float): Distance of search space.
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
* :func:`NiaPy.algorithms.other.aso.AnarchicSocietyOptimization.init`
"""
X, X_f, d = Algorithm.initPopulation(self, task)
alpha, gamma, theta = self.init(task)
Xpb, Xpb_f = self.uBestAndPBest(X, X_f, full([self.NP, task.D], 0.0), full(self.NP, task.optType.value * inf))
d.update({'Xpb': Xpb, 'Xpb_f': Xpb_f, 'alpha': alpha, 'gamma': gamma, 'theta': theta, 'rs': self.d(task.Upper, task.Lower)})
return X, X_f, d
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 function/fitness value.
3. Additional arguments:
* enable (numpy.ndarray[bool]): If solution/individual is enabled.
* improve (numpy.ndarray[bool]): If solution/individual is improved.
* SR (numpy.ndarray): Search range.
* grades (numpy.ndarray[int]): Grade of solution/individual.
"""
X, X_f, d = Algorithm.initPopulation(self, task)
enable, improve, SR, grades = full(self.NP, True), full(
self.NP, True), full([self.NP, task.D],
task.bRange / 2), full(self.NP, 0.0)
d.update({
'enable': enable,
'improve': improve,
'SR': SR,
'grades': grades
})
return X, X_f, d
def initPopulation(self, task):
r"""Initialize population and dynamic arguments of the Particle Swarm Optimization algorithm.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
1. Initial population.
2. Initial population fitness/function values.
3. Additional arguments:
* popb (numpy.ndarray): particles best population.
* fpopb (numpy.ndarray[float]): particles best positions function/fitness value.
* w (numpy.ndarray): Inertial weight.
* vMin (numpy.ndarray): Minimal velocity.
* vMax (numpy.ndarray): Maximal velocity.
* V (numpy.ndarray): Initial velocity of particle.
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
pop, fpop, d = Algorithm.initPopulation(self, task)
d.update(self.init(task))
d.update({'popb': pop, 'fpopb': fpop})
return pop, fpop, d
def test_init_population_individual_fine(self): r"""Test if custome generation initialization works ok.""" a = Algorithm(NP=10, InitPopFunc=init_pop_individual, itype=Individual) t = Task(D=20, benchmark=MyBenchmark()) i = Individual(x=full(t.D, 0.0), task=t) pop, fpop, d = a.initPopulation(t) for e in pop: self.assertEqual(i, e)
def initPopulation(self, task):
r"""Initialize the individuals.
Args:
task (Task): Optimization task
Returns:
Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]:
1. Initialized population of individuals
2. Function/fitness values for individuals
3. Additional arguments
"""
return Algorithm.initPopulation(self, task)
def initPopulation(self, task):
r"""Initialize stating point.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, float, Dict[str, Any]]:
1. New individual.
2. New individual function/fitness value.
3. Additional arguments.
"""
x, x_f, _ = Algorithm.initPopulation(self, task)
# x = task.Lower + self.rand(task.D) * task.bRange
return x, x_f, {}
def initPopulation(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.initPopulation(self, task)
for i in self.Rand.choice(self.NP, int(self.R * len(pop)), replace=False): pop[i].MonkeyKing = True
return pop, fpop, {}
def initPopulation(self, task, rnd=rand):
r"""Initialize the starting population.
Parameters:
task (Task): Optimization task
Returns:
Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
1. New population.
2. New population fitness/function values.
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
Sol, Fitness, d = Algorithm.initPopulation(self, task)
return Sol, Fitness, d
def initPopulation(self, task): r"""Initialize first population. Args: task (Task): Optimization task. Returns: Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]: 1. New harmony/population. 2. New population fitness/function values. 3. Additional parameters. See Also: * :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation` """ return Algorithm.initPopulation(self, task)
def initPopulation(self, task):
r"""Initialize starting population.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, float, Dict[str, Any]]:
1. Initial solution.
2. Initial solution function/fitness value.
3. Additional arguments:
* A (numpy.ndarray): Starting aplitude or search range.
"""
x, x_fit, d = Algorithm.initPopulation(self, task)
d.update({'A': task.bRange})
return x, x_fit, d
def initPopulation(self, task):
r"""Initialize 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:
* Ah (): TODO
* Ab (): TODO
"""
FW, FW_f, _ = Algorithm.initPopulation(self, task)
Ah, Ab = self.initAmplitude(task)
return FW, FW_f, {'Ah': Ah, 'Ab': Ab}
def initPopulation(self, task):
r"""Initialize population.
Args:
task (Task): Optimization taks.
Returns:
Tuple[numpy.ndarray[Camel], numpy.ndarray[float], dict]:
1. New population of Camels.
2. New population fitness/function values.
3. Additional arguments.
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
caravan, fcaravan, _ = Algorithm.initPopulation(self, task)
return caravan, fcaravan, {}
def initPopulation(self, task):
r"""Initialize starting population.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, float, Dict[str, Any]]:
1. Initial solution.
2. Initial solution function/fitness value.
3. Additional arguments:
* A (numpy.ndarray): Starting aplitude or search range.
"""
# x, A = self.uniform(task.Lower, task.Upper, task.D), task.bRange
x, x_fit, A = Algorithm.initPopulation(self, task)
# x_fit = task.eval(x)
return x, x_fit, {'A': A}
def initPop(self, task, NP, rnd, **kwargs): r"""Init starting population. Args: NP (int): Number of individuals in population. task (Task): Optimization task. rnd (mtrand.RandomState): Random number generator. kwargs (Dict[str, Any]): Additional arguments. Returns: Tuple[numpy.ndarray, numpy.ndarray[float]]: 1. New initialized population. 2. New initialized population fitness/function values. """ # X = self.uniform(task.Lower, task.Upper, [task.D if NP is None or NP < task.D else NP, task.D]) # X_f = apply_along_axis(task.eval, 1, X) X, X_f, _ = Algorithm.initPopulation(self, task) return X, X_f
def initPopulation(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): TODO
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
Fireflies, Intensity, _ = Algorithm.initPopulation(self, task)
return Fireflies, Intensity, {'alpha': self.alpha}
def initPopulation(self, task):
r"""Initialize staring 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
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
"""
X, X_f, _ = Algorithm.initPopulation(self, task)
v = full([self.NP, task.D], 0.0)
return X, X_f, {'v': v}
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:
* pa_v (float): TODO
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
N, N_f, d = Algorithm.initPopulation(self, task)
d.update({'pa_v': self.NP * self.pa})
return N, N_f, d
def initPopulation(self, task):
r"""Initialize starting population.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray[Individual], numpy.ndarray[float], Dict[str, Any]]:
1. Initialized populaiton.
2. Initialized populations function/fitness values.
3. Additional arguments:
* ki (int): Number of successful mutations.
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
"""
c, fc, d = Algorithm.initPopulation(self, task)
d.update({'ki': 0})
return c, fc, d
def initPopulation(self, task):
r"""Initialize 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:
* Dictionary of modes (seek or trace) and velocities for each cat
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
pop, fpop, d = Algorithm.initPopulation(self, task)
d['modes'] = self.randomSeekTrace()
d['velocities'] = self.uniform(-self.vMax, self.vMax, [len(pop), task.D])
return pop, fpop, d
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 function/fitness values.
3. Additional arguments:
* Ah (numpy.ndarray): Initialized amplitudes.
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
"""
FW, FW_f, d = Algorithm.initPopulation(self, task)
Ah = self.initAmplitude(task)
d.update({'Ah': Ah})
return FW, FW_f, d
def initPopulation(self, task):
r"""Initialize the starting population.
Parameters:
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:
* Probes (numpy.ndarray): TODO
* Trial (numpy.ndarray): TODO
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
Foods, fpop, _ = Algorithm.initPopulation(self, task)
Probs, Trial = np.zeros(self.FoodNumber), np.zeros(self.FoodNumber)
return Foods, fpop, {'Probs': Probs, 'Trial': Trial}
def initPopulation(self, task):
r"""Initialize population.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]:
1. Initialized population of glowwarms.
2. Initialized populations function/fitness values.
3. Additional arguments:
* L (numpy.ndarray): TODO.
* R (numpy.ndarray): TODO.
* rs (numpy.ndarray): TODO.
"""
GS, GS_f, d = Algorithm.initPopulation(self, task)
rs = euclidean(np.zeros(task.D), task.bRange)
L, R = np.full(self.NP, self.l0), np.full(self.NP, rs)
d.update({'L': L, 'R': R, 'rs': rs})
return GS, GS_f, d
def initPopulation(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.initPopulation`
"""
Trees, Evaluations, _ = Algorithm.initPopulation(self, task)
age = zeros(self.NP, dtype=int32)
self.dx = absolute(task.benchmark.Upper) / 5
return Trees, Evaluations, {'age': age}
def initPopulation(self, task):
r"""Initialize 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:
* best_solution (float): Initial best solution.
* best_vector (numpy.ndarray): Initial best vector.
* direction_of_movement (int): Direction of ants movement.
* x_previous (float): Previous best solution.
* x_previous_vector (numpy.ndarray): Previous best vector.
* alphaMin (float): Minimum alpha.
* alphaMax (float): Maximum alpha.
* pheromone_quantity (float): Current quantity of pheromone.
See Also:
* :func:`NiaPy.algorithms.Algorithm.initPopulation`
"""
pop, fpop, d = Algorithm.initPopulation(self, task)
alphaMin, alphaMax = task.Lower, task.Upper
pheromone_quantity = self.pheromone
best_vector, best_solution = self.getBest(pop, fpop)
direction_of_movement = self.determineDirectionOfMovement(
best_solution)
x_previous, x_previous_vector = best_solution, best_vector
d.update({
'best_solution': best_solution,
'best_vector': best_vector,
'direction_of_movement': direction_of_movement,
'x_previous': x_previous,
'x_previous_vector': x_previous_vector,
'alphaMin': alphaMin,
'alphaMax': alphaMax,
'pheromone_quantity': pheromone_quantity
})
return pop, fpop, d
def initPopulation(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): TODO.
* c (int): TODO.
See Also:
* :func:`NiaPy.algorithms.algorithm.Algorithm.initPopulation`
"""
X, X_f, d = Algorithm.initPopulation(self, task)
k, c = int(ceil(self.NP / task.D)), int(ceil(self.C * task.D))
d.update({'k': k, 'c': c})
return X, X_f, d
