def run() -> None:
target_path = os.path.join(RESULTS_DIR,
f"test_{datetime.now().isoformat()}.json")
first_execution_unit = ExecutionUnit(
algorithm_cls=ClonalSelection, problem_name="DeJong1").register_run(
parameters={
"problem":
DeJong1(-5.12, 5.12, number_of_variables=50),
"population_size":
200,
"selection_size":
30,
"random_cells_number":
50,
"clone_rate":
20,
"mutation":
PolynomialMutation(probability=1 / 50, distribution_index=20),
"termination_criterion":
StoppingByEvaluations(max_evaluations=500)
})
problem_1 = DeJong1(-5.12, 5.12, number_of_variables=50)
problem_2 = DeJong1(-5.12, 5.12, number_of_variables=50)
second_execution_unit = ExecutionUnit(
algorithm_cls=ClonalSelectionCognitive, problem_name="DeJong1"
).register_run(
parameters={
"clonal_selections": [
ClonalSelection(
problem=problem_1,
population_size=200,
selection_size=30,
random_cells_number=50,
clone_rate=20,
mutation=PolynomialMutation(probability=1 /
problem_1.number_of_variables,
distribution_index=20),
),
ClonalSelection(
problem=problem_2,
population_size=200,
selection_size=30,
random_cells_number=50,
clone_rate=20,
mutation=PolynomialMutation(probability=2 /
problem_2.number_of_variables,
distribution_index=20),
)
],
"mix_rate":
0.4,
"mixes_number":
2,
"termination_criterion":
StoppingByEvaluations(max_evaluations=500)
})
runner = MultiAlgorithmRunner(
execution_units=[first_execution_unit, second_execution_unit])
print("Runner starts evaluation.")
results = runner.run_all()
print("Results")
for run_result in results.run_results:
print(run_result)
save_execution_history(execution_history=results, path=target_path)
from jmetal.algorithm.singleobjective.evolution_strategy import EvolutionStrategy
from jmetal.operator import PolynomialMutation
from jmetal.problem import Sphere
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == "__main__":
problem = Sphere(number_of_variables=10)
algorithm = EvolutionStrategy(
problem=problem,
mu=10,
lambda_=10,
elitist=True,
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables),
termination_criterion=StoppingByEvaluations(max_evaluations=25000),
)
algorithm.run()
result = algorithm.get_result()
print("Algorithm: " + algorithm.get_name())
print("Problem: " + problem.get_name())
print("Solution: " + str(result.variables[0]))
print("Fitness: " + str(result.objectives[0]))
print("Computing time: " + str(algorithm.total_computing_time))
from jmetal.algorithm.multiobjective.gde3 import GDE3
from jmetal.problem.singleobjective.unconstrained import Rastrigin
from jmetal.util.observer import PrintObjectivesObserver
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 = Rastrigin(10)
algorithm = GDE3(
problem=problem,
population_size=100,
cr=0.5,
f=0.5,
termination_criterion=StoppingByEvaluations(50000)
)
algorithm.observable.register(observer=PrintObjectivesObserver(1000))
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))
def default_termination_criteria(self):
return StoppingByEvaluations(max_evaluations=25000)
from framework.problems.singleobjective.ackley import Ackley
from jmetal.algorithm.singleobjective import GeneticAlgorithm
from jmetal.operator import PolynomialMutation, SBXCrossover, BinaryTournamentSelection
from jmetal.util.termination_criterion import StoppingByEvaluations
from evolutionary_memetic.memetic import MemeticAlgorithm, MemeticLocalSearch
if __name__ == '__main__':
problem = Ackley(number_of_variables=150)
max_evaluations = 1000
mutation = PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20)
local_search = MemeticLocalSearch(problem, mutation,
StoppingByEvaluations(500))
iterations = 200
results_memetic = list()
for i in range(iterations):
try:
algorithm = MemeticAlgorithm(
problem=problem,
population_size=500,
offspring_population_size=150,
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations))
algorithm.run()
def test_SMPSO(self):
SMPSO(problem=self.problem,
swarm_size=self.population_size,
mutation=self.mutation,
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(max=1000)).run()
def train(self):
problem = Ejemplo(X=self.Xtrain,
Y=self.Ytrain,
kernel=self.kernel,
gamma=self.gamma,
degree=self.degree,
C=self.C,
coef0=self.coef0)
#problem.reference_front = read_solutions(filename='resources/reference_front/ZDT1.pf')
max_evaluations = self.maxEvaluations
algorithm = NSGAII(
problem=problem,
population_size=self.popsize,
offspring_population_size=self.popsize,
mutation=BitFlipMutation(probability=1.0 /
np.shape(self.Xtrain)[0]),
crossover=SPXCrossover(probability=1.0),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
#algorithm.observable.register(observer=VisualizerObserver(reference_front=problem.reference_front))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation',
reference_front=None,
axis_labels=problem.obj_labels)
plot_front.plot(front,
label=algorithm.label,
filename=algorithm.get_name())
# Plot interactive front
plot_front = InteractivePlot(plot_title='Pareto front approximation',
axis_labels=problem.obj_labels)
plot_front.plot(front,
label=algorithm.label,
filename=algorithm.get_name())
# Save results to file
print_function_values_to_file(front, 'FUN.' + algorithm.label)
print_variables_to_file(front, 'VAR.' + algorithm.label)
print('Algorithm (continuous problem): ' + algorithm.get_name())
# Get normalized matrix of results
normed_matrix = normalize(
list(map(lambda result: result.objectives, front)))
# Get the sum of each objective results and select the best (min)
scores = list(map(lambda item: sum(item), normed_matrix))
solution = front[scores.index(min(scores))]
self.instances = solution.variables[0]
self.attributes = solution.variables[1]
# Generate masks
# Crop by characteristics and instances
X = self.Xtrain[self.instances, :]
X = X[:, self.attributes]
Y = self.Ytrain[self.instances]
self.model = SVC(gamma=self.gamma,
C=self.C,
degree=self.degree,
kernel=self.kernel)
self.model.fit(X=X, y=Y)
# write your code here
return self.model
def configurar_RandomSearch(self):
algorithm = RandomSearch(
problem = self.problema,
termination_criterion=StoppingByEvaluations(max_evaluations=self.evaluaciones))
return algorithm
def dtlz_test(p: FloatProblemGD, label: str = '', experiment: int = 50):
# problem.reference_front = read_solutions(filename='resources/reference_front/DTLZ2.3D.pf')
max_evaluations = 25000
# references = ReferenceDirectionFromSolution(p)
algorithm = NSGA3C(
problem=p,
population_size=100,
reference_directions=UniformReferenceDirectionFactory(p.instance_.n_obj, n_points=92),
mutation=PolynomialMutation(probability=1.0 / p.number_of_variables, distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=30),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
)
bag = []
total_time = 0
for i in range(experiment):
algorithm = NSGA3C(
problem=p,
population_size=92,
reference_directions=UniformReferenceDirectionFactory(p.instance_.n_obj, n_points=91),
mutation=PolynomialMutation(probability=1.0 / p.number_of_variables, distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=30),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
)
progress_bar = ProgressBarObserver(max=max_evaluations)
algorithm.observable.register(progress_bar)
algorithm.run()
total_time += algorithm.total_computing_time
bag = bag + algorithm.get_result()
print(len(bag))
print('Total computing time:', total_time)
print('Average time: ', str(total_time / experiment))
print_solutions_to_file(bag, DIRECTORY_RESULTS + 'Solutions.bag._class_' + label + algorithm.label)
ranking = FastNonDominatedRanking()
ranking.compute_ranking(bag)
front_ = ranking.get_subfront(0)
print('Front 0 size : ', len(front_))
alabels = []
for obj in range(p.number_of_objectives):
alabels.append('Obj-' + str(obj))
plot_front = Plot(title='Pareto front approximation' + ' ' + label,
axis_labels=alabels)
plot_front.plot(front_, label=label + 'F0 ' + algorithm.label,
filename=DIRECTORY_RESULTS + 'F0_class_' + 'original_' + label + algorithm.label,
format='png')
class_fronts = [[], [], [], []]
for s in front_:
_class = problem.classifier.classify(s)
if _class[0] > 0:
class_fronts[0].append(s)
elif _class[1] > 0:
class_fronts[1].append(s)
elif _class[2] > 0:
class_fronts[2].append(s)
else:
class_fronts[3].append(s)
print(len(class_fronts[0]), len(class_fronts[1]), len(class_fronts[2]), len(class_fronts[3]))
_front = class_fronts[0] + class_fronts[1]
if len(_front) == 0:
_front = class_fronts[2] + class_fronts[3]
print('Class : ', len(_front))
# Save results to file
print_solutions_to_file(_front, DIRECTORY_RESULTS + 'Class_F0' + label + algorithm.label)
print(f'Algorithm: ${algorithm.get_name()}')
print(f'Problem: ${p.get_name()}')
plot_front = Plot(title=label + 'F_' + p.get_name(), axis_labels=alabels)
plot_front.plot(_front, label=label + 'F_' + p.get_name(),
filename=DIRECTORY_RESULTS + 'Class_F0' + label + p.get_name(),
format='png')
def configure_experiment(problems: dict, n_run: int):
jobs = []
num_processes = config.num_cpu
population = 10
generations = 10
max_evaluations = population * generations
for run in range(n_run):
for problem_tag, problem in problems.items():
reference_point = FloatSolution([0, 0], [1, 1], problem.number_of_objectives, )
reference_point.objectives = np.repeat(1, problem.number_of_objectives).tolist()
jobs.append(
Job(
algorithm=NSGAIII(
problem=problem,
population_size=population,
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
population_evaluator=MultiprocessEvaluator(processes=num_processes),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
reference_directions=UniformReferenceDirectionFactory(4, n_points=100),
),
algorithm_tag='NSGAIII',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=GDE3(
problem=problem,
population_size=population,
population_evaluator=MultiprocessEvaluator(processes=num_processes),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
cr=0.5,
f=0.5,
),
algorithm_tag='GDE3',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=SPEA2(
problem=problem,
population_size=population,
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
population_evaluator=MultiprocessEvaluator(processes=num_processes),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
offspring_population_size=population,
),
algorithm_tag='SPEA2',
problem_tag=problem_tag,
run=run,
)
)
return jobs
import time
from framework.problems.singleobjective.ackley import Ackley
from evolutionary_memetic.memetic_cognitive import MemeticCognitiveAlgorithm, Species
import matplotlib.pyplot as plt
from jmetal.algorithm.singleobjective import GeneticAlgorithm
from jmetal.operator import PolynomialMutation, SBXCrossover, BinaryTournamentSelection
from jmetal.util.termination_criterion import StoppingByEvaluations
from evolutionary_memetic.memetic import MemeticAlgorithm, MemeticLocalSearch
if __name__ == '__main__':
problem = Ackley(number_of_variables=150)
max_evaluations = 500000
mutation = PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20)
local_search = MemeticLocalSearch(problem, mutation, StoppingByEvaluations(500))
memetic_algo = MemeticCognitiveAlgorithm(
problem=problem,
population_size=5000,
offspring_population_size=1000,
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
species1=Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
species2=Species(
mutation=mutation,
def get_algorithm_instance(algo_name):
algos = {
'smpso':
SMPSO(problem=objective_function,
swarm_size=swarm_size,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'omopso':
OMOPSO(problem=objective_function,
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=int(max_evaluations / swarm_size)),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'nsgaii':
NSGAII(problem=objective_function,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'spea2':
SPEA2(problem=objective_function,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
'moead':
MOEAD(
problem=objective_function,
population_size=30,
crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5, K=0.5),
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
aggregative_function=Tschebycheff(
dimension=objective_function.number_of_objectives),
neighbor_size=5,
neighbourhood_selection_probability=0.9,
max_number_of_replaced_solutions=2,
weight_files_path='resources/MOEAD_weights',
termination_criterion=StoppingByEvaluations(max_evaluations=700)),
'ibea':
IBEA(problem=objective_function,
kappa=1.0,
population_size=30,
offspring_population_size=30,
mutation=PolynomialMutation(probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations))
}
return algos[algo_name]
def run() -> None:
problem = Ackley(number_of_variables=150)
# problem = Griewank(number_of_variables=150)
# problem = Schwefel(number_of_variables=150)
# problem = SchafferF7(number_of_variables=150)
mutation = PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20)
local_search = MemeticLocalSearch(problem, mutation, StoppingByEvaluations(250))
local_search2 = MemeticLocalSearch(problem, mutation, StoppingByEvaluations(500))
max_evaluations = 1000000
drawing_class = DrawingClass(registered_runs=6)
target_path = os.path.join(RESULTS_DIR, f"test_{datetime.now().isoformat()}.json")
first_execution_unit = ExecutionUnit(
algorithm_cls=MemeticCognitiveAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["RUN1", "RUN1"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
second_execution_unit = ExecutionUnit(
algorithm_cls=MemeticCognitiveAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["RUN2", "RUN2"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 2500,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search2,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 2500,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"species1": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"species2": Species(
mutation=mutation,
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(),
local_search=local_search2,
termination_criterion=StoppingByEvaluations(max_evaluations=1000)
),
"local_search": local_search,
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
# modify genetic to get history (see MemeticCognitiveAlgorithm)
third_execution_unit = ExecutionUnit(
algorithm_cls=GeneticAlgorithm,
problem_name="Ackley",
drawing_fun=drawing_class.draw_avg_function,
drawing_series_labels=["GENETIC", "GENETIC"]
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
).register_run(
parameters={
"problem": problem,
"population_size": 5000,
"offspring_population_size": 1000,
"mutation": mutation,
"crossover": SBXCrossover(probability=1.0, distribution_index=20),
"selection": BinaryTournamentSelection(),
"termination_criterion": StoppingByEvaluations(max_evaluations=max_evaluations)
}
)
runner = MultiAlgorithmRunner(
execution_units=[
first_execution_unit, second_execution_unit, third_execution_unit
],
drawing_properties=
DrawingProperties(title='Memetic1', target_location=os.path.join(RESULTS_DIR, "photo.png"))
)
print("Runner starts evaluation.")
results = runner.run_all()
print("Results")
for run_result in results.run_results:
print(run_result)
save_execution_history(execution_history=results, path=target_path)
def train(self):
problem = SVM_Problem(X=self.Xtrain, Y=self.Ytrain)
#problem.reference_front = read_solutions(filename='resources/reference_front/ZDT1.pf')
max_evaluations = self.maxEvaluations
algorithm = NSGAII(
problem=problem,
population_size=self.popsize,
offspring_population_size=self.popsize,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
#algorithm.observable.register(observer=VisualizerObserver(reference_front=problem.reference_front))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation',
reference_front=None,
axis_labels=problem.obj_labels)
plot_front.plot(front,
label=algorithm.label,
filename=algorithm.get_name())
# Plot interactive front
plot_front = InteractivePlot(plot_title='Pareto front approximation',
axis_labels=problem.obj_labels)
plot_front.plot(front,
label=algorithm.label,
filename=algorithm.get_name())
# Save results to file
print_function_values_to_file(front, 'FUN.' + algorithm.label)
print_variables_to_file(front, 'VAR.' + algorithm.label)
print('Algorithm (continuous problem): ' + algorithm.get_name())
print(
"-----------------------------------------------------------------------------"
)
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
# Get normalized matrix of results
normed_matrix = normalize(
list(map(lambda result: result.objectives, front)))
# Get the sum of each objective results and select the best (min)
scores = list(map(lambda item: sum(item), normed_matrix))
solution = front[scores.index(min(scores))]
# Get our variables
self.gamma = solution.variables[0]
self.C = solution.variables[1]
self.coef0 = solution.variables[2]
self.degree = solution.variables[3]
self.kernel = solution.variables[4]
self.instances = solution.masks[0]
self.attributes = solution.masks[1]
# Select pick a random array with length of the variable
X = self.Xtrain[self.instances, :]
X = X[:, self.attributes]
Y = self.Ytrain[self.instances]
print(*front, sep=", ")
# Contruct model
self.model = SVM(Xtrain=X,
Ytrain=Y,
kernel=self.kernel,
C=self.C,
degree=self.degree,
coef0=self.coef0,
gamma=self.gamma,
seed=self.seed).train()
print('Objectives: ', *solution.objectives, sep=", ")
# write your code here
return self.model
problem.reference_front = read_solutions(filename='resources/reference_front/LZ09_F2.pf')
max_evaluations = 150000
algorithm = MOEAD_DRA(
problem=problem,
population_size=300,
crossover=DifferentialEvolutionCrossover(CR=1.0, F=0.5, K=0.5),
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20),
aggregative_function=Tschebycheff(dimension=problem.number_of_objectives),
neighbor_size=20,
neighbourhood_selection_probability=0.9,
max_number_of_replaced_solutions=2,
weight_files_path='resources/MOEAD_weights',
termination_criterion=StoppingByEvaluations(max=max_evaluations)
)
algorithm.observable.register(observer=ProgressBarObserver(max=max_evaluations))
algorithm.observable.register(
observer=VisualizerObserver(reference_front=problem.reference_front, display_frequency=1000))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(plot_title='Pareto front approximation', reference_front=problem.reference_front,
axis_labels=problem.obj_labels)
plot_front.plot(front, label=algorithm.label, filename=algorithm.get_name())
# Plot interactive front
from examples.multiobjective.zdt1_modified import ZDT1Modified
from jmetal.algorithm.multiobjective.gde3 import GDE3
from jmetal.util.evaluator import SparkEvaluator
from jmetal.util.solution import print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = ZDT1Modified()
algorithm = GDE3(problem=problem,
population_size=10,
cr=0.5,
f=0.5,
termination_criterion=StoppingByEvaluations(max=100),
population_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))
file_name = target_dir + '/reward' + str(round_index) + '.txt'
numpy.savetxt(file_name, reward, fmt="%f") # 保存为整数
file_name = target_dir + '/distance_ranking' + str(
round_index) + '.txt'
numpy.savetxt(file_name, distance_ranking, fmt="%f") # 保存为整数
file_name = target_dir + '/relation_ranking' + str(
round_index) + '.txt'
numpy.savetxt(file_name, relation_ranking, fmt="%f") # 保存为整数
Goal_num = Configuration.goal_num
"""===============================实例化问题对象============================"""
problem = CarBehindAndInFrontProblem(Goal_num, Configuration)
"""=================================算法参数设置============================"""
max_evaluations = Configuration.maxIterations
# StoppingEvaluator = StoppingByEvaluations(max_evaluations=max_evaluations, problem=problem)
StoppingEvaluator = StoppingByEvaluations(
max_evaluations=max_evaluations)
algorithm = NSGAIII(
initial_population=sorted_pop,
target_pattern=goal_selection_flag,
target_value_threshold=target_value_threshold,
population_evaluator=MultiprocessEvaluator(
Configuration.ProcessNum),
# population_evaluator=SequentialEvaluator(),
problem=problem,
population_size=Configuration.population,
reference_directions=UniformReferenceDirectionFactory(
Configuration.goal_num,
n_points=Configuration.population - 1),
# offspring_population_size = Configuration.population,
mutation=PolynomialMutation(probability=1.0 /
# phi_n: float - the weight for speed change influenced by neighborhood. Default is 0.3.
#
# n_neighbors: int - neighborhood size. Default is 30.
#
# hops: int - How is neighborhood determined (if neighbors' neighobrs should be also taken into account etc.)
# I would not change the number of hops from the default value 1, because it becomes computationally to expensive
# due to inefficient implementation.
#
# use_global: bool - whether to use global best while determining speed change. Default is False and it should not be
# changed because it gives poor results, but is left to be compliant with the specification given during lab exercises.
#
algorithm = WithNeighborsPSO(
problem=Rastrigin(100),
swarm_size=100,
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
100
) # To get better results increase the number of iterations, I tested for 10 000-50 000.
)
algorithm.run()
solutions = algorithm.get_result()
objectives = solutions[0].objectives
variables = solutions[0].variables
print("PSO with neighbors")
print("Fitness: {}".format(objectives))
# print("Variables: {}".format(variables))
