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