def Experiment(seedstrings):
problem = MADM()
seedset = []
while len(seedset) <= N_seeds:
for string in seedstrings:
seed = problem.create_solution()
seed.variables = string
seedset.append(seed)
max_evaluations = 100000
#algorithm = SPEA2(
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=IntegerPolynomialMutation(probability=0.1),
crossover=IntegerCrossover(probability=0.9),
termination_criterion=StoppingByEvaluations(max=max_evaluations),
population_generator=InjectorGenerator(seedset))
resultsets = algorithm.run()
process = []
for g in range(len(resultsets)):
process.append(get_non_dominated_solutions(resultsets[g]))
return process, algorithm.get_result()
def test_NSGAII(self):
NSGAII(problem=self.problem,
population_size=self.population_size,
offspring_population_size=self.offspring_size,
mutation=self.mutation,
crossover=self.crossover,
termination_criterion=StoppingByEvaluations(max=1000)).run()
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 configure_experiment(problems: dict, n_run: int):
jobs = []
max_evaluations = 25000
for run in range(n_run):
for problem_tag, problem in problems.items():
jobs.append(
Job(
algorithm=NSGAII(
problem=problem,
population_size=100,
offspring_population_size=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_tag="NSGAII",
problem_tag=problem_tag,
run=run,
))
jobs.append(
Job(
algorithm=GDE3(
problem=problem,
population_size=100,
cr=0.5,
f=0.5,
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations),
),
algorithm_tag="GDE3",
problem_tag=problem_tag,
run=run,
))
jobs.append(
Job(
algorithm=SMPSO(
problem=problem,
swarm_size=100,
mutation=PolynomialMutation(
probability=1.0 / problem.number_of_variables,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations),
),
algorithm_tag="SMPSO",
problem_tag=problem_tag,
run=run,
))
return jobs
def test_NSGAII(self):
NSGAII(
problem=self.problem,
population_size=self.population_size,
offspring_population_size=self.offspring_size,
mutation=self.mutation,
crossover=self.crossover,
selection=BinaryTournamentSelection(comparator=RankingAndCrowdingDistanceComparator()),
termination_criterion=StoppingByEvaluations(max=1000)
).run()
def train(self):
problem = BinProblem(X=self.Xtrain,
Y=self.Ytrain,
kernel=self.kernel,
gamma=self.gamma,
degree=self.degree,
C=self.C,
coef0=self.coef0)
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.run()
front = algorithm.get_result()
normed_matrix = normalize(
list(map(lambda result: result.objectives, front)))
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]
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)
return self.model
def configurar_NSGAII(self):
algorithm = NSGAII(
problem=self.problema,
population_size=self.maxima_poblacion,
offspring_population_size=self.maxima_poblacion,
mutation=PolynomialMutation(probability = self.probabilidad , distribution_index=0.20),
crossover=SBXCrossover(probability= self.probabilidad, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations=self.evaluaciones),
dominance_comparator=DominanceComparator())
return algorithm
def test_should_NSGAII_work_when_solving_problem_ZDT1_with_standard_settings(self):
problem = ZDT1()
max_evaluations = 25000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=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()
hv = HyperVolume(reference_point=[1, 1])
value = hv.compute([front[i].objectives for i in range(len(front))])
self.assertTrue(value >= 0.65)
def __NSGAII(self) -> None:
assert 'mutation' in self.__option
assert 'crossover' in self.__option
assert 'max_evaluation' in self.__option
assert 'tolerance' in self.__option
self.__solver = NSGAII(
problem=self.__problem,
population_size=POPULATION_SIZE,
offspring_population_size=OFFSPRING_SIZE,
# mutation=BitFlipMutation(probability=1.0/self.__problem.number_of_variables),
mutation=BitFlipMutation(probability=self.__option['mutation']),
crossover=SPXCrossover(probability=self.__option['crossover']),
termination_criterion=StoppingByEvaluations(max_evaluations=MAX_EVALUATION)
# termination_criterion=Terminator(max_evaluation=self.__option['max_evaluation'], tolerance=self.__option['tolerance'])
)
def configure_experiment(problems: dict, n_run: int):
jobs = []
for run in range(n_run):
for problem_tag, problem in problems.items():
jobs.append(
Job(
algorithm=NSGAII(
problem=problem,
population_size=20,
offspring_population_size=20,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
# termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
termination_criterion=stopCriterion
),
algorithm_tag='NSGAII',
problem_tag=problem_tag,
run=run,
)
)
jobs.append(
Job(
algorithm=SPEA2(
problem=problem,
population_size=20,
offspring_population_size=20,
mutation=IntegerPolynomialMutation(probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3, distribution_index=20),
termination_criterion=StoppingByEvaluations(max_evaluations=max_evaluations)
),
algorithm_tag='SPEA2',
problem_tag=problem_tag,
run=run,
)
)
return jobs
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
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_evaluations=25000))
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}')
def configurar_algoritmo(self,
hora_show: datetime,
hora_minima: datetime = datetime.time(0, 0),
algoritmo: str = 'MOGA',
mutation_probability: float = 0.25,
max_evaluations: int = 500,
population: int = 100):
hora_minima, hora_show = self.restricciones_hora(
hora_minima, hora_show)
if (hora_minima == 0):
hora_minima = hora_show - 180
restricciones_baja = list([hora_minima, -100, -100, 0, 0])
restricciones_alta = list([hora_show, 0, 0, 100, 100])
self.problem = HVAC(lower_bound=restricciones_baja,
upper_bound=restricciones_alta,
number_of_configurations=3)
print("algoritmo: ", algoritmo)
if algoritmo == 'MOGA':
algorithm = MOGA(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
elif algoritmo == "NSGAII":
algorithm = NSGAII(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
elif algoritmo == 'OMOPSO':
algorithm = OMOPSO(problem=self.problem,
swarm_size=population,
epsilon=0.0075,
uniform_mutation=UniformMutation(
probability=mutation_probability,
perturbation=0.5),
non_uniform_mutation=NonUniformMutation(
probability=mutation_probability,
perturbation=0.5),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max=max_evaluations))
elif algoritmo == 'SMPSO':
algorithm = SMPSO(problem=self.problem,
swarm_size=population,
mutation=IntegerPolynomialMutation(
probability=mutation_probability,
distribution_index=20),
leaders=CrowdingDistanceArchive(100),
termination_criterion=StoppingByEvaluations(
max=max_evaluations))
elif algoritmo == 'SPEA2':
algorithm = SPEA2(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
else:
print("Algoritmo no válido. Creando MOGA por defecto...")
algorithm = MOGA(problem=self.problem,
population_size=population,
offspring_population_size=population,
mutation=IntegerPolynomialMutationD(
probability=mutation_probability,
distribution_index=20),
crossover=SBXCrossoverD(
probability=mutation_probability,
distribution_index=20),
termination_criterion=StoppingByEvaluations(
max=max_evaluations),
dominance_comparator=DominanceComparator())
self.algoritmo = algorithm
self.algoritmo.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
return algorithm
# creates the problem
problem = BAliBASE(
instance='BB20019',
path='../resources',
score_list=[SumOfPairs(),
PercentageOfTotallyConservedColumns()])
# creates the algorithm
max_evaluations = 25000
reference_point = [-0.6, 11000]
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=ShiftClosedGapGroups(probability=0.3),
crossover=SPXMSA(probability=0.7),
dominance_comparator=GDominanceComparator(reference_point),
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
algorithm.observable.register(observer=PlotFrontToFileObserver(
output_directory='fronts_zdt1'))
algorithm.run()
front = algorithm.get_result()
# plot front
plot_front = Plot(title='Pareto front approximation',
def configure_experiment(problems: dict, n_run: int):
"""Configures the experiments
Args:
problems (dict): The MEWpy optimization problem
n_run (int): the number of runs of each MOEA
Returns:
a list of jobs
"""
from mewpy.optimization.jmetal.operators import UniformCrossoverOU, GrowMutationOU, ShrinkMutation, \
SingleMutationOU, MutationContainer
crossover = UniformCrossoverOU(0.5, max_size=candidate_max_size)
mutators = []
mutators.append(GrowMutationOU(1.0, max_size=candidate_max_size))
mutators.append(ShrinkMutation(1.0, min_size=candidate_max_size))
mutators.append(SingleMutationOU(1.0))
mutation = MutationContainer(0.3, mutators=mutators)
jobs = []
for run in range(n_run):
for problem_tag, problem in problems.items():
jobs.append(
Job(
algorithm=NSGAII(
problem=problem,
population_evaluator=MultiprocessEvaluator(N_CPU),
population_size=100,
offspring_population_size=100,
mutation=mutation,
crossover=crossover,
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
algorithm_tag='NSGAII',
problem_tag=problem_tag,
run=run,
))
jobs.append(
Job(algorithm=SPEA2(
problem=problem,
population_evaluator=MultiprocessEvaluator(N_CPU),
population_size=100,
offspring_population_size=100,
mutation=mutation,
crossover=crossover,
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
algorithm_tag='SPEA2',
problem_tag=problem_tag,
run=run))
jobs.append(
Job(
algorithm=IBEA(
problem=problem,
population_evaluator=MultiprocessEvaluator(N_CPU),
kappa=1.,
population_size=100,
offspring_population_size=100,
mutation=mutation,
crossover=crossover,
termination_criterion=StoppingByEvaluations(
max_evaluations=max_evaluations)),
algorithm_tag='IBEA',
problem_tag=problem_tag,
run=run,
))
return jobs
Net = Network(folderName="Topologia2")
for executions in range(timesToRun):
print("Interation number:", executions)
problem = OTNProblem(Net, len(Net.LinkBundles))
max_evaluations = 1000
# stopCriterion = StoppingByEvaluationsCustom(max_evaluations, [200, 2.1]) # To topology 1, 200 is enough
algorithm = NSGAII(problem=problem,
population_size=20,
offspring_population_size=20,
mutation=IntegerPolynomialMutation(
probability=0.05, distribution_index=20),
crossover=IntegerSBXCrossover(probability=0.3,
distribution_index=20),
termination_criterion=StoppingByEvaluationsCustom(
max_evaluations=max_evaluations,
reference_point=[5000, 2.1],
AlgorithmName='Reference')
# termination_criterion=stopCriterion
)
progress_bar = ProgressBarObserver(max=max_evaluations)
algorithm.observable.register(progress_bar)
algorithm.run()
solutions = algorithm.get_result()
for solution in solutions:
if not solution.objectives[1] >= 1.3:
from jmetal.util.termination_criterion import StoppingByEvaluations
"""
Distributed (synchronous) version of NSGA-II using Apache Spark.
"""
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=SparkEvaluator(),
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(smrseeds)
#Experiments
#No seeds: MOEAs
noseedprocessruns = []
reference = []
#noseedfront = []
for i in range(run):
problem = MADM()
seedset = []
max_evaluations = 100000
#algorithm = SPEA2(
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=IntegerPolynomialMutation(probability=0.1),
crossover=IntegerCrossover(probability=0.9),
termination_criterion=StoppingByEvaluations(max=max_evaluations),
)
# algorithm.observable.register(observer=ProgressBarObserver(max=max_evaluations))
# algorithm.observable.register(observer=VisualizerObserver())
resultsets = algorithm.run()
#print(len(resultsets))
process = []
for g in range(len(resultsets)):
process.append(get_non_dominated_solutions(resultsets[g]))
front = get_non_dominated_solutions(algorithm.get_result()) #process[-1]
process.append(front)
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),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
termination_criterion=StoppingByEvaluations(max=25000))
progress_bar = ProgressBarObserver(max=25000)
algorithm.observable.register(observer=progress_bar)
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.algorithm.multiobjective.nsgaii import NSGAII
from jmetal.operator import BitFlipMutation, SPXCrossover
from jmetal.problem.multiobjective.unconstrained import OneZeroMax
from jmetal.util.observer import ProgressBarObserver, VisualizerObserver
from jmetal.util.solutions 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 = OneZeroMax(binary_string_length)
max_evaluations = 50000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=BitFlipMutation(probability=1.0 / binary_string_length),
crossover=SPXCrossover(probability=1.0),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
algorithm.observable.register(observer=VisualizerObserver())
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(
k=self.number_of_variables)
return new_solution
def get_name(self):
return 'MultiObjective TSP'
if __name__ == '__main__':
problem = NSGA()
max_evaluations = 20000
algorithm = NSGAII(
problem=problem,
population_size=20,
offspring_population_size=20,
mutation=PermutationSwapMutation(probability=0.2),
# crossover=PMXCrossover(probability=0.9),
crossover=Order1Crossover(probability=0.9),
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,
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
Pnmut: float = 0.2
Tel: float = 0.5
Pmut: float = 0.05
generations: int = 50
pop_size: int = 30
Cr: float = 0.5
max_evaluations: float = generations * pop_size
problem: MulticastProblem = MulticastProblem(
Graph=gr, root_node=root_node, destination_nodes=destination_nodes)
algorithm = NSGAII(problem=problem,
population_size=pop_size,
offspring_population_size=int(pop_size * Cr),
mutation=MulticastMutation(probability=Pmut,
Pnmut=Pnmut,
G=gr),
crossover=MulticastCrossover(
probability=1.0,
root_node=root_node,
destination_nodes=destination_nodes,
graph=gr),
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)
plot_front = Plot(title='Pareto front approximation',
from jmetal.util.observer import ProgressBarObserver, VisualizerObserver
from jmetal.util.solutions import read_solutions, print_function_values_to_file, print_variables_to_file
from jmetal.util.termination_criterion import StoppingByEvaluations
from jmetal.lab.visualization import Plot, InteractivePlot
if __name__ == '__main__':
problem = ZDT1()
problem.reference_front = read_solutions(
filename='resources/reference_front/ZDT1.pf')
max_evaluations = 25000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=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=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',
Goal_num = Configuration.goal_num
"""===============================实例化问题对象============================"""
problem = TurnRightProblem(Goal_num, Configuration)
"""=================================算法参数设置============================"""
max_evaluations = Configuration.maxIterations
if Configuration.algorithm == "NSGA_II":
algorithm = NSGAII(
population_evaluator=MultiprocessEvaluator(Configuration.ProcessNum),
# population_evaluator=SequentialEvaluator(),
problem=problem,
population_size = Configuration.population,
offspring_population_size = Configuration.population,
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)
# termination_criterion = StoppingByQualityIndicator(quality_indicator=FitnessValue, expected_value=1, degree=0.9)
# selection = BinaryTournamentSelection()
)
elif Configuration.algorithm == "NSGA_III" or Configuration.algorithm == "NSGA_III_Adapt":
algorithm = NSGAIII(
population_evaluator=MultiprocessEvaluator(Configuration.ProcessNum),
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 / problem.number_of_variables, distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
termination_criterion = StoppingByEvaluations(max_evaluations=max_evaluations)
from jmetal.util.comparator import DominanceComparator
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__':
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=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())
if __name__ == '__main__':
problem = ZDT2()
problem.reference_front = read_solutions(
filename='../../../resources/reference_front/{}.pf'.format(
problem.get_name()))
reference_point = [0.8, 0.5]
max_evaluations = 25000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PolynomialMutation(probability=1.0 /
problem.number_of_variables,
distribution_index=20),
crossover=SBXCrossover(probability=1.0, distribution_index=20),
selection=BinaryTournamentSelection(
comparator=RankingAndCrowdingDistanceComparator()),
dominance_comparator=GDominanceComparator(reference_point),
termination_criterion=StoppingByEvaluations(max=max_evaluations))
algorithm.observable.register(observer=ProgressBarObserver(
max=max_evaluations))
algorithm.observable.register(
observer=VisualizerObserver(reference_front=problem.reference_front,
reference_point=(reference_point)))
algorithm.run()
front = algorithm.get_result()
print_variables_to_file,
)
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == "__main__":
problem = MixedIntegerFloatProblem(10, 10, 100, -100, -1000, 1000)
max_evaluations = 25000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=CompositeMutation([
IntegerPolynomialMutation(0.01, 20),
PolynomialMutation(0.01, 20.0)
]),
crossover=CompositeCrossover([
IntegerSBXCrossover(probability=1.0, distribution_index=20),
SBXCrossover(probability=1.0, 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)
from jmetal.operator import SBXCrossover, PolynomialMutation
from jmetal.problem.singleobjective.unconstrained import Rastrigin
from jmetal.util.observer import PrintObjectivesObserver
from jmetal.util.solutions import print_function_values_to_file, print_variables_to_file
from jmetal.util.solutions.comparator import DominanceComparator
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())
from jmetal.algorithm.multiobjective.nsgaii import NSGAII
from jmetal.operator import BitFlipMutation, SPXCrossover
from jmetal.problem.multiobjective.unconstrained import OneZeroMax
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 = OneZeroMax(binary_string_length)
max_evaluations = 50000
algorithm = NSGAII(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=BitFlipMutation(probability=1.0 / binary_string_length),
crossover=SPXCrossover(probability=1.0),
termination_criterion=StoppingByEvaluations(max=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}')
