def run_optimization(max_eval, num_nodes, pop_size, offspring, trial_name, year):
os_fold = os_sep()
if not os.path.exists('results' + os_fold + year):
os.makedirs('results' + os_fold + year)
multiprocessing.freeze_support()
problem = cequal()
max_evaluations = max_eval
algorithm = NSGAII(
population_evaluator=MultiprocessEvaluator(num_nodes),
problem=problem,
population_size=pop_size,
offspring_population_size=offspring,
mutation=PolynomialMutation(probability= 0.2, distribution_index=20),
crossover=SBXCrossover(probability=0.8, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
dominance_comparator=DominanceComparator()
)
algorithm.observable.register(ProgressBarObserver(max=max_evaluations))
algorithm.observable.register(observer=BasicObserver())
algorithm.run()
print(os.getcwd())
front = algorithm.get_result()
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time/3600))
print_function_values_to_file(front, 'results' + os_fold + year + os_fold + 'OBJ_' + algorithm.get_name() + "_" + trial_name + '.txt')
print_variables_to_file(front, 'results' + os_fold + year + os_fold + 'VAR_' + algorithm.get_name() + "_" + trial_name + '.txt')
def nsgaii_train(particoes, regras, instancias, classes):
problem = MixedIntegerFloatProblem(particoes, regras, instancias, classes)
max_evaluations = 10
algorithm = NSGAII(
problem=problem,
population_size=10,
offspring_population_size=10,
mutation=CompositeMutation([IntegerPolynomialMutation(0.05, 20),
IntegerPolynomialMutation(0.05, 20),
PolynomialMutation(0.05, 20.0)]),
crossover=CompositeCrossover([IntegerSBXCrossover(probability=0.95, distribution_index=20),
IntegerSBXCrossover(probability=0.95, distribution_index=20),
SBXCrossover(probability=0.95, distribution_index=20)]),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
)
algorithm.run()
front = get_non_dominated_solutions(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('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
minAcuracia = 0
index = -1
for i, f in enumerate(front):
if minAcuracia > f.objectives[0]:
minAcuracia = f.objectives[0]
index = i
#for variable in front[index].variables:
#print(variable.variables)
particoes = problem.alterar_centroids(front[index].variables[2].variables)
new_regras = problem.cromossomo_para_regras(front[index].variables[0].variables, front[index].variables[1].variables, problem.semente.qtdAntecedenteRegra, particoes)
return particoes, new_regras
if __name__ == '__main__':
problem = Rastrigin(10)
max_evaluations = 50000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20.0),
crossover=SBXCrossover(probability=0.9, distribution_index=20.0),
termination_criterion=StoppingByEvaluations(max=max_evaluations),
dominance_comparator=DominanceComparator())
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))
from examples.multiobjective.parallel.zdt1_modified import ZDT1Modified
from jmetal.algorithm.multiobjective.nsgaii import NSGAII
from jmetal.operator import SBXCrossover, PolynomialMutation
from jmetal.util.evaluator import DaskEvaluator
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),
population_evaluator=DaskEvaluator(),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.run()
front = algorithm.get_result()
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
from jmetal.lab.visualization import Plot, InteractivePlot
if __name__ == '__main__':
problem = FON_Problem()
max_evaluations = 20000
algorithm = NSGAII(
problem = problem,
population_size = 100,
offspring_population_size = 100,
mutation=PolynomialMutation(probability=0.05, 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=problem.reference_front, 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', reference_front=problem.reference_front, axis_labels=problem.obj_labels)
plot_front.plot(front, label=algorithm.label, filename=algorithm.get_name())
print('Algorithm (continuous problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
2902, 5235, 357, 6058, 4846, 8280, 1295, 181, 3264, 7285, 8806, 2344,
9203, 6806, 1511, 2172, 843, 4697, 3348, 1866, 5800, 4094, 2751, 64,
7181, 9167, 5579, 9461, 3393, 4602, 1796, 8174, 1691, 8854, 5902, 4864,
5488, 1129, 1111, 7597, 5406, 2134, 7280, 6465, 4084, 8564, 2593, 9954,
4731, 1347, 8984, 5057, 3429, 7635, 1323, 1146, 5192, 6547, 343, 7584,
3765, 8660, 9318, 5098, 5185, 9253, 4495, 892, 5080, 5297, 9275, 7515,
9729, 6200, 2138, 5480, 860, 8295, 8327, 9629, 4212, 3087, 5276, 9250,
1835, 9241, 1790, 1947, 8146, 8328, 973, 1255, 9733, 4314, 6912, 8007,
8911, 6802, 5102, 5451, 1026, 8029, 6628, 8121, 5509, 3603, 6094, 4447,
683, 6996, 3304, 3130, 2314, 7788, 8689, 3253, 5920, 3660, 2489, 8153,
2822, 6132, 7684, 3032, 9949, 59, 6669, 6334
]
problem = SubsetSum(C, W)
algorithm = NSGAII(problem=problem,
population_size=100,
offspring_population_size=100,
mutation=BitFlipMutation(probability=0.5),
crossover=SPXCrossover(probability=0.8),
termination_criterion=StoppingByEvaluations(max=25000))
algorithm.observable.register(observer=ProgressBarObserver(max=25000))
algorithm.run()
front = algorithm.get_result()
print('Algorithm (binary problem): ' + algorithm.get_name())
print('Problem: ' + problem.get_name())
print('Computing time: ' + str(algorithm.total_computing_time))
from jmetal.util.observer import PrintObjectivesObserver
from jmetal.util.solutions_utils import print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = Rastrigin(10)
max_evaluations = 50000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(probability=1.0 / problem.number_of_variables, distribution_index=20.0),
crossover=SBXCrossover(probability=0.9, distribution_index=20.0),
termination_criterion=StoppingByEvaluations(max=max_evaluations),
dominance_comparator=DominanceComparator()
)
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))
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
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)
from jmetal.util.comparator import DominanceComparator
from jmetal.util.solution import print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == "__main__":
binary_string_length = 512
problem = OneMax(binary_string_length)
max_evaluations = 20000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=1,
mutation=BitFlipMutation(probability=1.0 / binary_string_length),
crossover=SPXCrossover(probability=1.0),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations),
dominance_comparator=DominanceComparator(),
)
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))
max=max_evaluations))
algorithm.observable.register(observer=VisualizerObserver(
reference_front=problem.reference_front, display_frequency=100))
algorithm.run()
front = algorithm.get_result()
# Plot front
plot_front = Plot(
title="Pareto front approximation. Problem: " + problem.get_name(),
reference_front=problem.reference_front,
axis_labels=problem.obj_labels,
)
plot_front.plot(front,
label=algorithm.label,
filename=algorithm.get_name())
# Plot interactive front
plot_front = InteractivePlot(
title="Pareto front approximation. Problem: " + problem.get_name(),
reference_front=problem.reference_front,
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)
if __name__ == "__main__":
problem = Rastrigin(10)
max_evaluations = 50000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20.0),
crossover=SBXCrossover(probability=0.9, distribution_index=20.0),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations),
dominance_comparator=DominanceComparator(),
)
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 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 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
