def test_run_with_pool(self, fix_algorithm_object):
ms = MultipleSolving(fix_algorithm_object, 20)
pool = Pool(2)
ms.run(pool=pool)
assert ms.is_run
assert not (fix_algorithm_object.find_max !=
(ms.results_value_only[0] > ms.results_value_only[-1]))
def test_best_result(self, fix_algorithm_object):
ms = MultipleSolving(fix_algorithm_object, 20)
with pytest.raises(AttributeError):
print(ms.best_result)
ms.run()
assert isinstance(ms.best_result, tuple)
assert isinstance(ms.best_result[0], float)
assert isinstance(ms.best_result[1], list)
def test___init__(self, fix_algorithm_object):
"""Test __init__() constructor function."""
ms = MultipleSolving(fix_algorithm_object, 20)
assert ms.ori_algorithm_obj == fix_algorithm_object
assert ms.no_tries == 20
assert isinstance(ms.results, list)
assert isinstance(ms.results_value_only, list)
assert isinstance(ms.stat, dict)
assert not ms.is_run
def _ms_gen(self, x):
core_pso = PSO(optimization_object=self.ori_opt_object,
no_particles=math.ceil(x[0]),
no_iteration_steps=math.ceil(x[1]),
c_1=x[2],
c_2=x[3])
core_ms = \
MultipleSolving(algorithm_obj=core_pso,
no_tries=self.no_tries)
return core_ms
def run(self, **kwargs):
no_particles = kwargs.get('no_particles', 10)
no_iterations = kwargs.get('no_iterations', 20)
c_1 = kwargs.get('c_1', 2.0)
c_2 = kwargs.get('c_2', 2.0)
opt_obj = Optimization(optimizing_function=self._optimizing_function,
boundaries=[(0, self.max_particles),
(0, self.max_iteration),
(0, self.max_learning_factor),
(0, self.max_learning_factor)],
no_dimensions=4,
find_max=False)
opt_obj.add_constraint(self._constraint_function)
pso = PSO(optimization_object=opt_obj,
no_particles=no_particles,
no_iteration_steps=no_iterations,
c_1=c_1,
c_2=c_2,
verbose=True)
ms = MultipleSolving(algorithm_obj=pso,
no_tries=kwargs.get('no_tries', 5))
max_thread = kwargs.get('max_thread', 0)
ms.run(pool=Pool(max_thread if max_thread else None))
return ms
def test___repr__(self, fix_algorithm_object):
ms = MultipleSolving(fix_algorithm_object, 20)
assert ms.__repr__().find("Multiple") != -1
ms.run()
print_string = ms.__repr__()
for s in [
"Multiple solving for", "Best result", "Stat", "Range", "Mean",
"Median"
]:
assert print_string.find(s) != -1
return x[0] * 40 + x[1] * 50
def constraint(x):
return (x[0] + x[1] <= 50) & \
(x[0] * 3 + x[1] * 4 <= 180) & \
(x[1] <= 40)
optimization = Optimization(
optimizing_function=optimizing_function,
boundaries=[(0, 100), (0, 100)],
no_dimensions=2,
find_max=True
)
optimization.add_constraint(constraint)
pso = PSO(
optimization_object=optimization,
no_particles=10,
no_iteration_steps=20,
c_1=2.0,
c_2=2.0
)
ms = MultipleSolving(pso, 20)
ms.run()
print(ms)
'no_particles': p,
'no_iteration_steps': i,
'c_1': general_c1,
'c_2': general_c2
})
writer = csv.writer(args.output_file)
writer.writerow([
'#Particles', '#IterSteps', 'Mean', 'Median', 'StdDev',
'SuccessRate'
])
for test_case in test_cases:
pso = PSO(optimization_object=ROSENBROCK['optimization'],
**test_case)
ms = MultipleSolving(pso, 200)
ms.run(Pool())
writer.writerow([
# Particles
test_case['no_particles'],
# IterSteps
test_case['no_iteration_steps'],
# Mean
statistics.mean(ms.results_value_only),
# Median
statistics.median(ms.results_value_only),
# StdDev
statistics.stdev(ms.results_value_only),
# SuccessRate
calculate_success_rate(ms.results_value_only, max_error=0.05)
])
(5, 100.0),
],
no_dimensions=4,
find_max=True
)
optimization_2_years.add_constraint(year_2.check_consumption)
pso_1st = PSO(
optimization_object=optimization_2_years,
no_particles=40,
no_iteration_steps=20,
c_1=2.0,
c_2=2.0
)
print("Result for 1st case:")
ms_1st = MultipleSolving(pso_1st, 10)
ms_1st.run()
print(ms_1st)
# 2nd case: 3 year production planning with linear profit model
def profit_calculator_2nd(x, prices):
"""
:type x: list(float)
:type prices: list(float)
:rtype: float
"""
if len(x) == len(prices):
total = 0.0
for i in range(len(x)):
total += x[i] * prices[i]