def init(self, task):
r"""Initialize dynamic arguments of Particle Swarm Optimization algorithm.
Args:
task (Task): Optimization task.
Returns:
Dict[str, np.ndarray]:
* vMin: Mininal velocity.
* vMax: Maximal velocity.
* V: Initial velocity of particle.
* flag: Refresh gap counter.
"""
return {
'vMin':
full_array(self.vMin, task.D),
'vMax':
full_array(self.vMax, task.D),
'V':
np.full([self.NP, task.D], 0.0),
'flag':
np.full(self.NP, 0),
'Pc':
np.asarray([
.05 + .45 * (np.exp(10 * (i - 1) / (self.NP - 1)) - 1) /
(np.exp(10) - 1) for i in range(self.NP)
])
}
def initWeights(self, task):
r"""Initialize weights.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, numpy.ndarray]:
1. Weights for neighborhood.
2. Weights for foraging.
"""
return full_array(self.W_n, task.D), full_array(self.W_f, task.D)
def init(self, task):
r"""Initialize dynamic parameters of algorithm.
Args:
task (Task): Optimization task.
Returns:
Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]
1. Array of `self.alpha` propagated values
2. Array of `self.gamma` propagated values
3. Array of `self.theta` propagated values
"""
return full_array(self.alpha, self.NP), full_array(
self.gamma, self.NP), full_array(self.theta, self.NP)
def init(self, task):
r"""Initialize dynamic arguments of Particle Swarm Optimization algorithm.
Args:
task (Task): Optimization task.
Returns:
Dict[str, Union[float, np.ndarray]]:
* w (numpy.ndarray): Inertial weight.
* vMin (numpy.ndarray): Mininal velocity.
* vMax (numpy.ndarray): Maximal velocity.
* V (numpy.ndarray): Initial velocity of particle.
"""
return {
'w': full_array(self.w, task.D),
'vMin': full_array(self.vMin, task.D),
'vMax': full_array(self.vMax, task.D),
'V': np.full([self.NP, task.D], 0.0)
}
def __init__(self,
D=0,
optType=OptimizationType.MINIMIZATION,
benchmark=None,
Lower=None,
Upper=None,
frepair=repair.limit,
**kwargs):
r"""Initialize task class for optimization.
Arguments:
D (Optional[int]): Number of dimensions.
optType (Optional[OptimizationType]): Set the type of optimization.
benchmark (Union[str, Benchmark]): Problem to solve with optimization.
Lower (Optional[numpy.ndarray]): Lower limits of the problem.
Upper (Optional[numpy.ndarray]): Upper limits of the problem.
frepair (Optional[Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray, Dict[str, Any]], numpy.ndarray]]): Function for reparing individuals components to desired limits.
See Also:
* `func`:NiaPy.util.Utility.__init__`
* `func`:NiaPy.util.Utility.repair`
"""
# dimension of the problem
self.D = D
# set optimization type
self.optType = optType
# set optimization function
self.benchmark = Utility().get_benchmark(
benchmark) if benchmark is not None else None
if self.benchmark is not None:
self.Fun = self.benchmark.function(
) if self.benchmark is not None else None
# set Lower limits
if Lower is not None:
self.Lower = full_array(Lower, self.D)
elif Lower is None and benchmark is not None:
self.Lower = full_array(self.benchmark.Lower, self.D)
else:
self.Lower = full_array(0, self.D)
# set Upper limits
if Upper is not None:
self.Upper = full_array(Upper, self.D)
elif Upper is None and benchmark is not None:
self.Upper = full_array(self.benchmark.Upper, self.D)
else:
self.Upper = full_array(0, self.D)
# set range
self.bRange = self.Upper - self.Lower
# set repair function
self.frepair = frepair
def generateIndividual(self, D, upper, lower): u, l = full_array(upper, D), full_array(lower, D) return default_rng().uniform(l, u, D)
def test_a_int_list3_fine(self): a = [25 + i for i in range(10)] A = full_array(a, 9) a.remove(34) self.assertTrue(np.array_equal(A, np.asarray(a)))
def test_a_int_array2_fine(self): a = [25 + i for i in range(10)] A = full_array(np.asarray(a), 13) a.extend([25 + i for i in range(3)]) self.assertTrue(np.array_equal(A, np.asarray(a)))
def test_a_float_array1_fine(self): a = [25.25 + i for i in range(10)] A = full_array(np.asarray(a), 15) a.extend([25.25 + i for i in range(5)]) self.assertTrue(np.array_equal(A, np.asarray(a)))
def test_a_int_array_fine(self): a = np.asarray([25 for i in range(10)]) A = full_array(a, 10) self.assertTrue(np.array_equal(A, np.full(10, 25)))
def test_a_float_list_fine(self): a = [25.25 for i in range(10)] A = full_array(a, 10) self.assertTrue(np.array_equal(A, np.full(10, 25.25)))
def test_a_int_fine(self): A = full_array(25, 10) self.assertTrue(np.array_equal(A, np.full(10, 25)))
def test_lower(self): self.assertTrue(np.array_equal(full_array(self.Lower, self.D), self.task.Lower)) self.assertTrue(np.array_equal(full_array(self.Lower, self.D), self.task.bcLower()))
def setUp(self): self.D = 10 self.Upper, self.Lower = full_array(10, self.D), full_array(-10, self.D) self.met = repair.limit
def test_a_float_array3_fine(self): a = [25.25 + i for i in range(10)] A = full_array(np.asarray(a), 9) a.remove(34.25) self.assertTrue(np.array_equal(A, np.asarray(a)))
def test_upper(self): self.assertTrue(np.array_equal(full_array(self.Upper, self.D), self.task.Upper)) self.assertTrue(np.array_equal(full_array(self.Upper, self.D), self.task.bcUpper()))
def test_is_feasible(self): self.assertFalse(self.task.isFeasible(full_array([1, 2, 3], self.D)))
def test_range(self): self.assertTrue(np.array_equal(full_array(self.Upper, self.D) - full_array(self.Lower, self.D), self.task.bRange)) self.assertTrue(np.array_equal(full_array(self.Upper, self.D) - full_array(self.Lower, self.D), self.task.bcRange()))
