NiaPy.algorithms.other.mts.MultipleTrajectorySearch.getParameters() - Code Metrics - Inspection of "Development" - NiaOrg/NiaPy - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#233)

by Grega
created 2019-11-11 07:45 UTC
MultipleTrajectorySearch.getParameters() A

↳ Parent: NiaPy.algorithms.other.mts
Complexity

Conditions
Size

Total Lines	18
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	12
nop	1
dl	0
loc	18
rs	9.8
c	0
b	0
f	0
# encoding=utf8
# pylint: disable=mixed-indentation, multiple-statements, consider-using-enumerate, unused-argument, bad-continuation, line-too-long, redefined-builtin, arguments-differ, superfluous-parens
import logging
import operator as oper

from numpy import random as rand, vectorize, argwhere, copy, apply_along_axis, argmin, argsort, fmin, fmax, full, asarray, abs, inf

from NiaPy.algorithms.algorithm import Algorithm

logging.basicConfig()
logger = logging.getLogger('NiaPy.algorithms.other')
logger.setLevel('INFO')

__all__ = ['MultipleTrajectorySearch', 'MultipleTrajectorySearchV1', 'MTS_LS1', 'MTS_LS1v1', 'MTS_LS2', 'MTS_LS3', 'MTS_LS3v1']

def MTS_LS1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=rand, **ukwargs):
	r"""Multiple trajectory local search one.

	Args:
		Xk (numpy.ndarray): Current solution.
		Xk_fit (float): Current solutions fitness/function value.
		Xb (numpy.ndarray): Global best solution.
		Xb_fit (float): Global best solutions fitness/function value.
		improve (bool): Has the solution been improved.
		SR (numpy.ndarray): Search range.
		task (Task): Optimization task.
		BONUS1 (int): Bonus reward for improving global best solution.
		BONUS2 (int): Bonus reward for improving solution.
		sr_fix (numpy.ndarray): Fix when search range is to small.
		rnd (mtrand.RandomState): Random number generator.
		**ukwargs (Dict[str, Any]): Additional arguments.

	Returns:
		Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]:
			1. New solution.
			2. New solutions fitness/function value.
			3. Global best if found else old global best.
			4. Global bests function/fitness value.
			5. If solution has improved.
			6. Search range.
	"""
	if not improve:
		SR /= 2
		ifix = argwhere(SR < 1e-15)
		SR[ifix] = task.bRange[ifix] * sr_fix
	improve, grade = False, 0.0
	for i in range(len(Xk)):
		Xk_i_old = Xk[i]
		Xk[i] = Xk_i_old - SR[i]
		Xk = task.repair(Xk, rnd)
		Xk_fit_new = task.eval(Xk)
		if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk.copy(), Xk_fit_new
		if Xk_fit_new == Xk_fit: Xk[i] = Xk_i_old
		elif Xk_fit_new > Xk_fit:
			Xk[i] = Xk_i_old + 0.5 * SR[i]
			Xk = task.repair(Xk, rnd)
			Xk_fit_new = task.eval(Xk)
			if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk.copy(), Xk_fit_new
			if Xk_fit_new >= Xk_fit: Xk[i] = Xk_i_old
			else: grade, improve, Xk_fit = grade + BONUS2, True, Xk_fit_new
		else: grade, improve, Xk_fit = grade + BONUS2, True, Xk_fit_new
	return Xk, Xk_fit, Xb, Xb_fit, improve, grade, SR

def MTS_LS1v1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=rand, **ukwargs):
	r"""Multiple trajectory local search one version two.

	Args:
		Xk (numpy.ndarray): Current solution.
		Xk_fit (float): Current solutions fitness/function value.
		Xb (numpy.ndarray): Global best solution.
		Xb_fit (float): Global best solutions fitness/function value.
		improve (bool): Has the solution been improved.
		SR (numpy.ndarray): Search range.
		task (Task): Optimization task.
		BONUS1 (int): Bonus reward for improving global best solution.
		BONUS2 (int): Bonus reward for improving solution.
		sr_fix (numpy.ndarray): Fix when search range is to small.
		rnd (mtrand.RandomState): Random number generator.
		**ukwargs (Dict[str, Any]): Additional arguments.

	Returns:
		Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]:
			1. New solution.
			2. New solutions fitness/function value.
			3. Global best if found else old global best.
			4. Global bests function/fitness value.
			5. If solution has improved.
			6. Search range.
	"""
	if not improve:
		SR /= 2
		ifix = argwhere(SR < 1e-15)
		SR[ifix] = task.bRange[ifix] * sr_fix
	improve, D, grade = False, rnd.uniform(-1, 1, task.D), 0.0
	for i in range(len(Xk)):
		Xk_i_old = Xk[i]
		Xk[i] = Xk_i_old - SR[i] * D[i]
		Xk = task.repair(Xk, rnd)
		Xk_fit_new = task.eval(Xk)
		if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk.copy(), Xk_fit_new
		elif Xk_fit_new == Xk_fit: Xk[i] = Xk_i_old
		elif Xk_fit_new > Xk_fit:
			Xk[i] = Xk_i_old + 0.5 * SR[i]
			Xk = task.repair(Xk, rnd)
			Xk_fit_new = task.eval(Xk)
			if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk.copy(), Xk_fit_new
			elif Xk_fit_new >= Xk_fit: Xk[i] = Xk_i_old
			else: grade, improve, Xk_fit = grade + BONUS2, True, Xk_fit_new
		else: grade, improve, Xk_fit = grade + BONUS2, True, Xk_fit_new
	return Xk, Xk_fit, Xb, Xb_fit, improve, grade, SR

def genNewX(x, r, d, SR, op):
	r"""Move solution to other position based on operator.

	Args:
		x (numpy.ndarray): Solution to move.
		r (int): Random number.
		d (float): Scale factor.
		SR (numpy.ndarray): Search range.
		op (operator): Operator to use.

	Returns:
		numpy.ndarray: Moved solution based on operator.
	"""
	return op(x, SR * d) if r == 0 else x

def MTS_LS2(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=rand, **ukwargs):
	r"""Multiple trajectory local search two.

	Args:
		Xk (numpy.ndarray): Current solution.
		Xk_fit (float): Current solutions fitness/function value.
		Xb (numpy.ndarray): Global best solution.
		Xb_fit (float): Global best solutions fitness/function value.
		improve (bool): Has the solution been improved.
		SR (numpy.ndarray): Search range.
		task (Task): Optimization task.
		BONUS1 (int): Bonus reward for improving global best solution.
		BONUS2 (int): Bonus reward for improving solution.
		sr_fix (numpy.ndarray): Fix when search range is to small.
		rnd (mtrand.RandomState): Random number generator.
		**ukwargs (Dict[str, Any]): Additional arguments.

	Returns:
		Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]:
			1. New solution.
			2. New solutions fitness/function value.
			3. Global best if found else old global best.
			4. Global bests function/fitness value.
			5. If solution has improved.
			6. Search range.

	See Also:
		* :func:`NiaPy.algorithms.other.genNewX`
	"""
	if not improve:
		SR /= 2
		ifix = argwhere(SR < 1e-15)
		SR[ifix] = task.bRange[ifix] * sr_fix
	improve, grade = False, 0.0
	for _ in range(len(Xk)):
		D = -1 + rnd.rand(len(Xk)) * 2
		R = rnd.choice([0, 1, 2, 3], len(Xk))
		Xk_new = task.repair(vectorize(genNewX)(Xk, R, D, SR, oper.sub), rnd)
		Xk_fit_new = task.eval(Xk_new)
		if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk_new.copy(), Xk_fit_new
		elif Xk_fit_new != Xk_fit:
			if Xk_fit_new > Xk_fit:
				Xk_new = task.repair(vectorize(genNewX)(Xk, R, D, SR, oper.add), rnd)
				Xk_fit_new = task.eval(Xk_new)
				if Xk_fit_new < Xb_fit: grade, Xb, Xb_fit = grade + BONUS1, Xk_new.copy(), Xk_fit_new
				elif Xk_fit_new < Xk_fit: grade, Xk, Xk_fit, improve = grade + BONUS2, Xk_new.copy(), Xk_fit_new, True
			else: grade, Xk, Xk_fit, improve = grade + BONUS2, Xk_new.copy(), Xk_fit_new, True
	return Xk, Xk_fit, Xb, Xb_fit, improve, grade, SR

def MTS_LS3(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, rnd=rand, **ukwargs):
	r"""Multiple trajectory local search three.

	Args:
		Xk (numpy.ndarray): Current solution.
		Xk_fit (float): Current solutions fitness/function value.
		Xb (numpy.ndarray): Global best solution.
		Xb_fit (float): Global best solutions fitness/function value.
		improve (bool): Has the solution been improved.
		SR (numpy.ndarray): Search range.
		task (Task): Optimization task.
		BONUS1 (int): Bonus reward for improving global best solution.
		BONUS2 (int): Bonus reward for improving solution.
		rnd (mtrand.RandomState): Random number generator.
		**ukwargs (Dict[str, Any]): Additional arguments.

	Returns:
		Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]:
			1. New solution.
			2. New solutions fitness/function value.
			3. Global best if found else old global best.
			4. Global bests function/fitness value.
			5. If solution has improved.
			6. Search range.
	"""
	Xk_new, grade = copy(Xk), 0.0
	for i in range(len(Xk)):
		Xk1, Xk2, Xk3 = copy(Xk_new), copy(Xk_new), copy(Xk_new)
		Xk1[i], Xk2[i], Xk3[i] = Xk1[i] + 0.1, Xk2[i] - 0.1, Xk3[i] + 0.2
		Xk1, Xk2, Xk3 = task.repair(Xk1, rnd), task.repair(Xk2, rnd), task.repair(Xk3, rnd)
		Xk1_fit, Xk2_fit, Xk3_fit = task.eval(Xk1), task.eval(Xk2), task.eval(Xk3)
		if Xk1_fit < Xb_fit: grade, Xb, Xb_fit, improve = grade + BONUS1, Xk1.copy(), Xk1_fit, True
		if Xk2_fit < Xb_fit: grade, Xb, Xb_fit, improve = grade + BONUS1, Xk2.copy(), Xk2_fit, True
		if Xk3_fit < Xb_fit: grade, Xb, Xb_fit, improve = grade + BONUS1, Xk3.copy(), Xk3_fit, True
		D1, D2, D3 = Xk_fit - Xk1_fit if abs(Xk1_fit) != inf else 0, Xk_fit - Xk2_fit if abs(Xk2_fit) != inf else 0, Xk_fit - Xk3_fit if abs(Xk3_fit) != inf else 0
		if D1 > 0: grade, improve = grade + BONUS2, True
		if D2 > 0: grade, improve = grade + BONUS2, True
		if D3 > 0: grade, improve = grade + BONUS2, True
		a, b, c = 0.4 + rnd.rand() * 0.1, 0.1 + rnd.rand() * 0.2, rnd.rand()
		Xk_new[i] += a * (D1 - D2) + b * (D3 - 2 * D1) + c
		Xk_new = task.repair(Xk_new, rnd)
		Xk_fit_new = task.eval(Xk_new)
		if Xk_fit_new < Xk_fit:
			if Xk_fit_new < Xb_fit: Xb, Xb_fit, grade = Xk_new.copy(), Xk_fit_new, grade + BONUS1
			else: grade += BONUS2
			Xk, Xk_fit, improve = Xk_new, Xk_fit_new, True
	return Xk, Xk_fit, Xb, Xb_fit, improve, grade, SR

def MTS_LS3v1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, phi=3, BONUS1=10, BONUS2=1, rnd=rand, **ukwargs):
	r"""Multiple trajectory local search three version one.

	Args:
		Xk (numpy.ndarray): Current solution.
		Xk_fit (float): Current solutions fitness/function value.
		Xb (numpy.ndarray): Global best solution.
		Xb_fit (float): Global best solutions fitness/function value.
		improve (bool): Has the solution been improved.
		SR (numpy.ndarray): Search range.
		task (Task): Optimization task.
		phi (int): Number of new generated positions.
		BONUS1 (int): Bonus reward for improving global best solution.
		BONUS2 (int): Bonus reward for improving solution.
		rnd (mtrand.RandomState): Random number generator.
		**ukwargs (Dict[str, Any]): Additional arguments.

	Returns:
		Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]:
			1. New solution.
			2. New solutions fitness/function value.
			3. Global best if found else old global best.
			4. Global bests function/fitness value.
			5. If solution has improved.
			6. Search range.
	"""
	grade, Disp = 0.0, task.bRange / 10
	while True in (Disp > 1e-3):
		Xn = apply_along_axis(task.repair, 1, asarray([rnd.permutation(Xk) + Disp * rnd.uniform(-1, 1, len(Xk)) for _ in range(phi)]), rnd)
		Xn_f = apply_along_axis(task.eval, 1, Xn)
		iBetter, iBetterBest = argwhere(Xn_f < Xk_fit), argwhere(Xn_f < Xb_fit)
		grade += len(iBetterBest) * BONUS1 + (len(iBetter) - len(iBetterBest)) * BONUS2
		if len(Xn_f[iBetterBest]) > 0:
			ib, improve = argmin(Xn_f[iBetterBest]), True
			Xb, Xb_fit, Xk, Xk_fit = Xn[iBetterBest][ib][0].copy(), Xn_f[iBetterBest][ib][0], Xn[iBetterBest][ib][0].copy(), Xn_f[iBetterBest][ib][0]
		elif len(Xn_f[iBetter]) > 0:
			ib, improve = argmin(Xn_f[iBetter]), True
			Xk, Xk_fit = Xn[iBetter][ib][0].copy(), Xn_f[iBetter][ib][0]
		Su, Sl = fmin(task.Upper, Xk + 2 * Disp), fmax(task.Lower, Xk - 2 * Disp)
		Disp = (Su - Sl) / 10
	return Xk, Xk_fit, Xb, Xb_fit, improve, grade, SR

class MultipleTrajectorySearch(Algorithm):
	r"""Implementation of Multiple trajectory search.

	Algorithm:
		Multiple trajectory search

	Date:
		2018

	Authors:
		Klemen Berkovic

	License:
		MIT

	Reference URL:
		https://ieeexplore.ieee.org/document/4631210/

	Reference paper:
		Lin-Yu Tseng and Chun Chen, "Multiple trajectory search for Large Scale Global Optimization," 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), Hong Kong, 2008, pp. 3052-3059. doi: 10.1109/CEC.2008.4631210

	Attributes:
		Name (List[Str]): List of strings representing algorithm name.
		LSs (Iterable[Callable[[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, Task, Dict[str, Any]], Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, int, numpy.ndarray]]]): Local searches to use.
		BONUS1 (int): Bonus for improving global best solution.
		BONUS2 (int): Bonus for improving solution.
		NoLsTests (int): Number of test runs on local search algorithms.
		NoLs (int): Number of local search algorithm runs.
		NoLsBest (int): Number of locals search algorithm runs on best solution.
		NoEnabled (int): Number of best solution for testing.

	See Also:
		* :class:`NiaPy.algorithms.Algorithm`
	"""
	Name = ['MultipleTrajectorySearch', 'MTS']

	@staticmethod
	def algorithmInfo():
		r"""Get basic information of algorithm.

		Returns:
			str: Basic information of algorithm.

		See Also:
			* :func:`NiaPy.algorithms.Algorithm.algorithmInfo`
		"""
		return r"""Lin-Yu Tseng and Chun Chen, "Multiple trajectory search for Large Scale Global Optimization," 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), Hong Kong, 2008, pp. 3052-3059. doi: 10.1109/CEC.2008.4631210"""

	@staticmethod

	def typeParameters():
		r"""Get dictionary with functions for checking values of parameters.

		Returns:
			Dict[str, Callable]:
				* M (Callable[[int], bool])
				* NoLsTests (Callable[[int], bool])
				* NoLs (Callable[[int], bool])
				* NoLsBest (Callable[[int], bool])
				* NoEnabled (Callable[[int], bool])
				* BONUS1 (Callable([[Union[int, float], bool])
				* BONUS2 (Callable([[Union[int, float], bool])
		"""
		return {
			'M': lambda x: isinstance(x, int) and x > 0,
			'NoLsTests': lambda x: isinstance(x, int) and x >= 0,
			'NoLs': lambda x: isinstance(x, int) and x >= 0,
			'NoLsBest': lambda x: isinstance(x, int) and x >= 0,
			'NoEnabled': lambda x: isinstance(x, int) and x > 0,
			'BONUS1': lambda x: isinstance(x, (int, float)) and x > 0,
			'BONUS2': lambda x: isinstance(x, (int, float)) and x > 0,
		}

	def setParameters(self, M=40, NoLsTests=5, NoLs=5, NoLsBest=5, NoEnabled=17, BONUS1=10, BONUS2=1, LSs=(MTS_LS1, MTS_LS2, MTS_LS3), **ukwargs):
		r"""Set the arguments of the algorithm.

		Arguments:
			M (int): Number of individuals in population.
			NoLsTests (int): Number of test runs on local search algorithms.
			NoLs (int): Number of local search algorithm runs.
			NoLsBest (int): Number of locals search algorithm runs on best solution.
			NoEnabled (int): Number of best solution for testing.
			BONUS1 (int): Bonus for improving global best solution.
			BONUS2 (int): Bonus for improving self.
			LSs (Iterable[Callable[[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, Task, Dict[str, Any]], Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, int, numpy.ndarray]]]): Local searches to use.

		See Also:
			* :func:`NiaPy.algorithms.Algorithm.setParameters`
		"""
		Algorithm.setParameters(self, NP=ukwargs.pop('NP', M), **ukwargs)
		self.NoLsTests, self.NoLs, self.NoLsBest, self.NoEnabled, self.BONUS1, self.BONUS2 = NoLsTests, NoLs, NoLsBest, NoEnabled, BONUS1, BONUS2
		self.LSs = LSs

	def getParameters(self):
		r"""Get parameters values for the algorithm.

		Returns:
			Dict[str, Any]:
		"""
		d = Algorithm.getParameters(self)
		d.update({
			'M': d.pop('NP', self.NP),
			'NoLsTests': self.NoLsTests,
			'NoLs': self.NoLs,
			'NoLsBest': self.NoLsBest,
			'BONUS1': self.BONUS1,
			'BONUS2': self.BONUS2,
			'NoEnabled': self.NoEnabled,
			'LSs': self.LSs
		})
		return d

	def GradingRun(self, x, x_f, xb, fxb, improve, SR, task):
		r"""Run local search for getting scores of local searches.

		Args:
			x (numpy.ndarray): Solution for grading.
			x_f (float): Solutions fitness/function value.
			xb (numpy.ndarray): Global best solution.
			fxb (float): Global best solutions function/fitness value.
			improve (bool): Info if solution has improved.
			SR (numpy.ndarray): Search range.
			task (Task): Optimization task.

		Returns:
			Tuple[numpy.ndarray, float, numpy.ndarray, float]:
				1. New solution.
				2. New solutions function/fitness value.
				3. Global best solution.
				4. Global best solutions fitness/function value.
		"""
		ls_grades, Xn = full(3, 0.0), [[x, x_f]] * len(self.LSs)
		for k in range(len(self.LSs)):
			for _ in range(self.NoLsTests):
				Xn[k][0], Xn[k][1], xb, fxb, improve, g, SR = self.LSs[k](Xn[k][0], Xn[k][1], xb, fxb, improve, SR, task, BONUS1=self.BONUS1, BONUS2=self.BONUS2, rnd=self.Rand)
				ls_grades[k] += g
		xn, xn_f = min(Xn, key=lambda x: x[1])
		return xn, xn_f, xb, fxb, k


	def LsRun(self, k, x, x_f, xb, fxb, improve, SR, g, task):
		r"""Run a selected local search.

		Args:
			k (int): Index of local search.
			x (numpy.ndarray): Current solution.
			x_f (float): Current solutions function/fitness value.
			xb (numpy.ndarray): Global best solution.
			fxb (float): Global best solutions fitness/function value.
			improve (bool): If the solution has improved.
			SR (numpy.ndarray): Search range.
			g (int): Grade.
			task (Task): Optimization task.

		Returns:
			Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, int]:
				1. New best solution found.
				2. New best solutions found function/fitness value.
				3. Global best solution.
				4. Global best solutions function/fitness value.
				5. If the solution has improved.
				6. Grade of local search run.
		"""
		for _j in range(self.NoLs):
			x, x_f, xb, fxb, improve, grade, SR = self.LSs[k](x, x_f, xb, fxb, improve, SR, task, BONUS1=self.BONUS1, BONUS2=self.BONUS2, rnd=self.Rand)
			g += grade
		return x, x_f, xb, fxb, improve, SR, g

	def initPopulation(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.
					* SR (numpy.ndarray): Search range.
					* grades (numpy.ndarray): 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 runIteration(self, task, X, X_f, xb, xb_f, enable, improve, SR, grades, **dparams):
		r"""Core function of MultipleTrajectorySearch algorithm.

		Args:
			task (Task): Optimization task.
			X (numpy.ndarray): Current population of individuals.
			X_f (numpy.ndarray): Current individuals function/fitness values.
			xb (numpy.ndarray): Global best individual.
			xb_f (float): Global best individual function/fitness value.
			enable (numpy.ndarray): Enabled status of individuals.
			improve (numpy.ndarray): Improved status of individuals.
			SR (numpy.ndarray): Search ranges of individuals.
			grades (numpy.ndarray): Grades of individuals.
			**dparams (Dict[str, Any]): Additional arguments.

		Returns:
			Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]:
				1. Initialized population.
				2. Initialized populations function/fitness value.
				3. New global best solution.
				4. New global best solutions fitness/objective value.
				5. Additional arguments:
					* enable (numpy.ndarray): If solution/individual is enabled.
					* improve (numpy.ndarray): If solution/individual is improved.
					* SR (numpy.ndarray): Search range.
					* grades (numpy.ndarray): Grade of solution/individual.
		"""
		for i in range(len(X)):
			if not enable[i]: continue
			enable[i], grades[i] = False, 0
			X[i], X_f[i], xb, xb_f, k = self.GradingRun(X[i], X_f[i], xb, xb_f, improve[i], SR[i], task)
			X[i], X_f[i], xb, xb_f, improve[i], SR[i], grades[i] = self.LsRun(k, X[i], X_f[i], xb, xb_f, improve[i], SR[i], grades[i], task)
		for _ in range(self.NoLsBest): _, _, xb, xb_f, _, _, _ = MTS_LS1(xb, xb_f, xb, xb_f, False, task.bRange.copy() / 10, task, rnd=self.Rand)
		enable[argsort(grades)[:self.NoEnabled]] = True

		return X, X_f, xb, xb_f, {'enable': enable, 'improve': improve, 'SR': SR, 'grades': grades}

class MultipleTrajectorySearchV1(MultipleTrajectorySearch):
	r"""Implementation of Multiple trajectory search.

	Algorithm:
		Multiple trajectory search

	Date:
		2018

	Authors:
		Klemen Berkovic

	License:
		MIT

	Reference URL:
		https://ieeexplore.ieee.org/document/4983179/

	Reference paper:
		Tseng, Lin-Yu, and Chun Chen. "Multiple trajectory search for unconstrained/constrained multi-objective optimization." Evolutionary Computation, 2009. CEC'09. IEEE Congress on. IEEE, 2009.

	Attributes:
		Name (List[str]): List of strings representing algorithm name.

	See Also:
		* :class:`NiaPy.algorithms.other.MultipleTrajectorySearch``
	"""
	Name = ['MultipleTrajectorySearchV1', 'MTSv1']

	@staticmethod
	def algorithmInfo():
		r"""Get basic information of algorithm.

		Returns:
			str: Basic information of algorithm.

		See Also:
			* :func:`NiaPy.algorithms.Algorithm.algorithmInfo`
		"""
		return r"""Tseng, Lin-Yu, and Chun Chen. "Multiple trajectory search for unconstrained/constrained multi-objective optimization." Evolutionary Computation, 2009. CEC'09. IEEE Congress on. IEEE, 2009."""

	def setParameters(self, **kwargs):
		r"""Set core parameters of MultipleTrajectorySearchV1 algorithm.

		Args:
			**kwargs (Dict[str, Any]): Additional arguments.

		See Also:
			* :func:`NiaPy.algorithms.other.MultipleTrajectorySearch.setParameters`
		"""
		kwargs.pop('NoLsBest', None)
		MultipleTrajectorySearch.setParameters(self, NoLsBest=0, LSs=(MTS_LS1v1, MTS_LS2), **kwargs)

# vim: tabstop=3 noexpandtab shiftwidth=3 softtabstop=3

NiaOrg / NiaPy

Pull Request — master (#233)

MultipleTrajectorySearch.getParameters() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
