def test_calculate_updates():
"""Test calculate_updates method"""
X = np.array([[0, 1, 0, 1], [0, 0, 0, 0], [1, 1, 1, 1], [1, 1, 1, 1],
[0, 0, 1, 1], [1, 0, 0, 0]])
y = np.reshape(np.array([1, 1, 0, 0, 1, 1]), [6, 1])
nodes = [4, 2, 1]
fitness = NetworkWeights(X,
y,
nodes,
activation=identity,
bias=False,
is_classifier=False,
learning_rate=1)
a = list(np.arange(8) + 1)
b = list(0.01 * (np.arange(2) + 1))
weights = a + b
fitness.evaluate(weights)
problem = ContinuousOpt(10, fitness, maximize=False)
updates = problem.calculate_updates()
update1 = np.array([[-0.0017, -0.0034], [-0.0046, -0.0092],
[-0.0052, -0.0104], [0.0014, 0.0028]])
update2 = np.array([[-3.17], [-4.18]])
assert (np.allclose(updates[0], update1, atol=0.001)
and np.allclose(updates[1], update2, atol=0.001))
def test_random():
"""Test random method"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=4)
rand = problem.random()
assert (len(rand) == 5 and max(rand) >= 0 and min(rand) <= 4)
def test_reproduce_mut0():
"""Test reproduce method when mutation_prob is 0"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=1,
step=1)
father = np.array([0, 0, 0, 0, 0])
mother = np.array([1, 1, 1, 1, 1])
child = problem.reproduce(father, mother, mutation_prob=0)
assert (len(child) == 5 and sum(child) > 0 and sum(child) < 5)
def test_reproduce_mut1_range_gt_step():
"""Test reproduce method when mutation_prob is 1 and range is
greater than step size"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=2,
step=1)
father = np.array([0, 0, 0, 0, 0])
mother = np.array([2, 2, 2, 2, 2])
child = problem.reproduce(father, mother, mutation_prob=1)
assert (len(child) == 5 and sum(child) > 0 and sum(child) < 10)
def test_random_neighbor_range_eq_step():
"""Test random_neighbor method when range equals step size"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=1,
step=1)
x = np.array([0, 0, 1, 1, 1])
problem.set_state(x)
neigh = problem.random_neighbor()
sum_diff = np.sum(np.abs(x - neigh))
assert (len(neigh) == 5 and sum_diff == 1)
def test_hill_climb_continuous_min():
"""Test hill_climb function for a continuous minimization problem"""
problem = ContinuousOpt(5, OneMax(), maximize=False)
best_state, best_fitness, _ = hill_climb(problem, restarts=20)
x = np.array([0, 0, 0, 0, 0])
assert (np.array_equal(best_state, x) and best_fitness == 0)
def test_genetic_alg_continuous_min():
"""Test genetic_alg function for a continuous minimization problem"""
problem = ContinuousOpt(5, OneMax(), maximize=False)
best_state, best_fitness, _ = genetic_alg(problem, max_attempts=200)
x = np.array([0, 0, 0, 0, 0])
assert (np.allclose(best_state, x, atol=0.5) and best_fitness < 1)
def test_update_state_in_range():
"""Test update_state method where all updated values are within the
tolerated range"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=20,
step=1)
x = np.array([0, 1, 2, 3, 4])
problem.set_state(x)
y = np.array([2, 4, 6, 8, 10])
updated = problem.update_state(y)
assert np.array_equal(updated, (x + y))
def test_simulated_annealing_continuous_min():
"""Test simulated_annealing function for a continuous minimization
problem"""
problem = ContinuousOpt(5, OneMax(), maximize=False)
best_state, best_fitness, _ = simulated_annealing(problem,
max_attempts=50)
x = np.array([0, 0, 0, 0, 0])
assert (np.array_equal(best_state, x) and best_fitness == 0)
def test_update_state_outside_range():
"""Test update_state method where some updated values are outside the
tolerated range"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=5,
step=1)
x = np.array([0, 1, 2, 3, 4])
problem.set_state(x)
y = np.array([2, -4, 6, -8, 10])
updated = problem.update_state(y)
z = np.array([2, 0, 5, 0, 5])
assert np.array_equal(updated, z)
def test_random_neighbor_range_gt_step():
"""Test random_neighbor method when range greater than step size"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=2,
step=1)
x = np.array([0, 1, 2, 3, 4])
problem.set_state(x)
neigh = problem.random_neighbor()
abs_diff = np.abs(x - neigh)
abs_diff[abs_diff > 0] = 1
sum_diff = np.sum(abs_diff)
assert (len(neigh) == 5 and sum_diff == 1)
def test_random_hill_climb_continuous_max():
"""Test random_hill_climb function for a continuous maximization
problem"""
problem = ContinuousOpt(5, OneMax(), maximize=True)
best_state, best_fitness, _ = random_hill_climb(problem,
max_attempts=10,
restarts=20)
x = np.array([1, 1, 1, 1, 1])
assert (np.array_equal(best_state, x) and best_fitness == 5)
def test_random_pop():
"""Test random_pop method"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=1,
step=1)
problem.random_pop(100)
pop = problem.get_population()
pop_fitness = problem.get_pop_fitness()
assert (np.shape(pop)[0] == 100 and np.shape(pop)[1] == 5
and np.sum(pop) > 0 and np.sum(pop) < 500
and len(pop_fitness) == 100)
def test_find_neighbors_range_gt_step():
"""Test find_neighbors method when range greater than step size"""
problem = ContinuousOpt(5,
OneMax(),
maximize=True,
min_val=0,
max_val=2,
step=1)
x = np.array([0, 1, 2, 1, 0])
problem.set_state(x)
problem.find_neighbors()
neigh = np.array([[1, 1, 2, 1, 0], [0, 0, 2, 1, 0], [0, 2, 2, 1, 0],
[0, 1, 1, 1, 0], [0, 1, 2, 0, 0], [0, 1, 2, 2, 0],
[0, 1, 2, 1, 1]])
assert np.array_equal(np.array(problem.neighbors), neigh)
def rate(self, co_type: str, co_value: float):
"""Calculates the preference of characteristic objects using the defined stochastic method.
Parameters
----------
co_type: str
Type of preference values of objects characteristic of the COMET method
co_value: float
The value of preferences of objects characteristic of the COMET method
Returns
-------
"""
model = Comet(self._criteria)
model.generate_co()
model.rate_co(co_type, co_value)
dict_arg = {
'model': model,
'alternatives': self._alternatives,
'preference': self._alternativesPreference
}
if self._stochasticMethod == "hill-climbing":
problem = ContinuousOpt(model.get_co_len(),
CustomFitness(self._mlrose_fitness,
**dict_arg),
maximize=False,
step=0.01)
pos, _, cost_history = hill_climb(
problem,
max_iters=self._iterations,
curve=True,
init_state=model.get_co_preference())
cost_history = np.abs(cost_history)
elif self._stochasticMethod == "simulated-annealing":
problem = ContinuousOpt(model.get_co_len(),
CustomFitness(self._mlrose_fitness,
**dict_arg),
maximize=False,
step=0.01)
pos, _, cost_history = simulated_annealing(
problem,
max_iters=self._iterations,
curve=True,
init_state=model.get_co_preference())
cost_history = np.abs(cost_history)
elif self._stochasticMethod == "pso":
bound_max = np.ones(model.get_co_len())
bound_min = np.zeros(model.get_co_len())
bounds = (bound_min, bound_max)
options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9}
optimizer = single.GlobalBestPSO(n_particles=20,
dimensions=model.get_co_len(),
options=options,
bounds=bounds)
cost, pos = optimizer.optimize(self._pso_fitness, self._iterations,
**dict_arg)
cost_history = optimizer.cost_history
else:
raise ValueError(
"Wrong optimization method has been determined: %s" %
(repr(self._stochasticMethod)))
return pos, cost_history
