def stopping_condition_is_met(self):
if self.termination_criterion.is_met:
observable_data = self.get_observable_data()
observable_data['termination_criterion_is_met'] = True
self.observable.notify_all(**observable_data)
print_function_values_to_file(self.leaders.solution_list,
'FUN.DynamicSMPSO.' + str(self.completed_iterations))
self.restart()
self.init_progress()
self.completed_iterations += 1
def stopping_condition_is_met(self):
if self.termination_criterion.is_met:
observable_data = self.get_observable_data()
self.observable.notify_all(**observable_data)
self.restart()
self.init_progress()
self.completed_iterations += 1
print_function_values_to_file(
self.solutions,
'FUN.DynamicGDE3.' + str(self.completed_iterations))
def execute(self, output_path: str = ''):
self.algorithm.run()
if output_path:
file_name = os.path.join(output_path,
'FUN.{}.tsv'.format(self.run_tag))
print_function_values_to_file(self.algorithm.get_result(),
filename=file_name)
file_name = os.path.join(output_path,
'VAR.{}.tsv'.format(self.run_tag))
print_variables_to_file(self.algorithm.get_result(),
filename=file_name)
file_name = os.path.join(output_path,
'TIME.{}'.format(self.run_tag))
with open(file_name, 'w+') as of:
of.write(str(self.algorithm.total_computing_time))
def update(self, *args, **kwargs):
problem = kwargs['PROBLEM']
solutions = kwargs['SOLUTIONS']
if solutions:
if isinstance(problem, DynamicProblem):
termination_criterion_is_met = kwargs.get(
'TERMINATION_CRITERIA_IS_MET', None)
if termination_criterion_is_met:
print_function_values_to_file(
solutions, '{}/FUN.{}'.format(self.directory,
self.counter))
self.counter += 1
else:
print_function_values_to_file(
solutions, '{}/FUN.{}'.format(self.directory,
self.counter))
self.counter += 1
max_evaluations = 100
swarm_size = 10
algorithm = OMOPSO(
problem=problem,
swarm_size=swarm_size,
epsilon=0.0075,
uniform_mutation=UniformMutation(probability=mutation_probability,
perturbation=0.5),
non_uniform_mutation=NonUniformMutation(
mutation_probability,
perturbation=0.5,
max_iterations=max_evaluations / swarm_size),
leaders=CrowdingDistanceArchive(10),
termination_criterion=StoppingByEvaluations(max=max_evaluations),
swarm_evaluator=SparkEvaluator(),
)
algorithm.run()
front = algorithm.get_result()
# Save results to file
print_function_values_to_file(
front, 'FUN.' + algorithm.get_name() + "." + problem.get_name())
print_variables_to_file(
front, 'VAR.' + algorithm.get_name() + "." + problem.get_name())
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
termination_criterion=StoppingByEvaluations(max=max_evaluations),
dominance_comparator=DominanceComparator())
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
algorithm.observable.register(observer=VisualizerObserver(
reference_front=problem.reference_front))
algorithm.run()
front = algorithm.get_result()
label = algorithm.get_name() + "." + problem.get_name()
algorithm_name = label
# Plot front
plot_front = Plot(plot_title='Pareto front approximation',
axis_labels=problem.obj_labels)
plot_front.plot(front, label=label, filename=algorithm_name)
# Plot interactive front
plot_front = InteractivePlot(plot_title='Pareto front approximation',
axis_labels=problem.obj_labels)
plot_front.plot(front, label=label, filename=algorithm_name)
# Save results to file
print_function_values_to_file(front, 'FUN.' + label)
print_variables_to_file(front, 'VAR.' + label)
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
from jmetal.util.solution_list import print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = ZDT1Modified()
max_evaluations = 100
algorithm = NSGAII(
problem=problem,
population_size=10,
offspring_population_size=10,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.run()
front = algorithm.get_result()
# Save results to file
print_function_values_to_file(front, 'FUN.NSGAII.ZDT1')
print_variables_to_file(front, 'VAR.NSGAII.ZDT1')
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
from jmetal.util.archive import CrowdingDistanceArchive
from jmetal.util.neighborhood import C9
from jmetal.util.solution import read_solutions
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = ZDT1()
problem.reference_front = read_solutions(filename='resources/reference_front/ZDT4.pf')
max_evaluations = 25000
algorithm = MOCell(
problem=problem,
population_size=100,
neighborhood=C9(10, 10),
archive=CrowdingDistanceArchive(100),
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
)
algorithm.run()
front = algorithm.get_result()
# Save results to file
print_function_values_to_file(front, 'FUN.' + algorithm.label)
print_variables_to_file(front, 'VAR.'+ algorithm.label)
print(f'Algorithm: ${algorithm.get_name()}')
print(f'Problem: ${problem.get_name()}')
print(f'Computing time: ${algorithm.total_computing_time}')
