def construct(self, hyperparameters: Mapping, scenario: Mapping,
warm_startup_info: Mapping) -> None:
problem_init_params = HashableDict(
scenario['problem_initialization_parameters'])
problem = self._get_problem(scenario['Problem'], problem_init_params)
self.load_initial_solutions(warm_startup_info, problem)
from jmetal.operator.mutation import PermutationSwapMutation
termination_criterion_cls = self._get_class_from_module(
name=scenario["Budget"]["Type"], module=termination)
termination_criterion = termination_criterion_cls(
scenario["Budget"]["Amount"])
mh_name = hyperparameters["low level heuristic"].split(".")[1]
if mh_name == "GeneticAlgorithm":
from jmetal.algorithm.singleobjective.genetic_algorithm import (
GeneticAlgorithm)
from jmetal.operator.crossover import CXCrossover
from jmetal.operator.selection import BinaryTournamentSelection
self._llh_algorithm = GeneticAlgorithm(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PermutationSwapMutation(0.5),
crossover=CXCrossover(0.5),
selection=BinaryTournamentSelection(),
termination_criterion=termination_criterion,
population_generator=self._solution_generator)
elif mh_name == "SimulatedAnnealing":
from jmetal.algorithm.singleobjective.simulated_annealing import (
SimulatedAnnealing)
self._llh_algorithm = SimulatedAnnealing(
problem=problem,
mutation=PermutationSwapMutation(0.5),
termination_criterion=termination_criterion,
solution_generator=self._solution_generator)
elif mh_name == "EvolutionStrategy":
from jmetal.algorithm.singleobjective.evolution_strategy import (
EvolutionStrategy)
self._llh_algorithm = EvolutionStrategy(
problem=problem,
mu=500,
lambda_=500,
elitist=False,
mutation=PermutationSwapMutation(0.5),
termination_criterion=termination_criterion,
population_generator=self._solution_generator)
else:
self.logger.error(f"Wrong meta-heuristic name: {mh_name}")
from jmetal.util.density_estimator import CrowdingDistance
from jmetal.util.observer import PrintObjectivesObserver
from jmetal.util.ranking import FastNonDominatedRanking
from jmetal.util.solutions.comparator import MultiComparator
from jmetal.util.termination_criterion import StoppingByEvaluations
if __name__ == '__main__':
problem = TSP(instance='../../resources/TSP_instances/kroA100.tsp')
print('Cities: ', problem.number_of_variables)
algorithm = GeneticAlgorithm(
problem=problem,
population_size=100,
offspring_population_size=100,
mutation=PermutationSwapMutation(1.0 / problem.number_of_variables),
crossover=PMXCrossover(0.8),
selection=BinaryTournamentSelection(
MultiComparator([
FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()
])),
termination_criterion=StoppingByEvaluations(max=2500000))
algorithm.observable.register(observer=PrintObjectivesObserver(1000))
algorithm.run()
result = algorithm.get_result()
print('Algorithm: {}'.format(algorithm.get_name()))
print('Problem: {}'.format(problem.get_name()))
available_time = vsc.get_available_time()
metric.update_available_time(available_time)
test_cases = vsc.get_testcases()
IND_SIZE = len(test_cases)
if (IND_SIZE > 1):
# Run GA to find the best NAPFD in current commit
problem = TCPCI(metric=metric, test_cases=test_cases,
number_of_variables=IND_SIZE)
algorithm = GeneticAlgorithm(
problem=problem,
population_size=300,
offspring_population_size=300,
mutation=PermutationSwapMutation(0.01),
crossover=PMXCrossover(0.9),
selection=BinaryTournamentSelection(),
termination_criterion=StoppingByEvaluations(max=60000)
)
# algorithm.observable.register(observer=PrintObjectivesObserver(1000))
algorithm.run()
result = algorithm.get_result()
print(f"Commit: {t} - Fitness: {result.objectives[0]*-1} - Computing time: {algorithm.total_computing_time}")
else:
print(f"Commit: {t} - Fitness: {1}")
# print('Algorithm: ' + algorithm.get_name())
# print('Problem: ' + problem.get_name())
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 create_solution(self) -> PermutationSolution:
new_solution = PermutationSolution(
number_of_variables=self.number_of_variables,
number_of_objectives=self.number_of_objectives
)
new_solution.variables = random.sample(range(self.number_of_variables), k=self.number_of_variables)
return new_solution
def get_name(self):
return 'Symmetric TSP'
algorithm = GeneticAlgorithm(
problem=TSP(),
population_size=4,
offspring_population_size=4,
# To Get a Different Combination by swapping any two positions
mutation=PermutationSwapMutation(1.0 / 4),
# Partially Mapped Crossover
# Basically, parent 1 donates a swath of genetic material and the
# corresponding swath from the other parent is sprinkled about in the child.
# Once that is done, the remaining alleles are copied direct from parent 2.
crossover=PMXCrossover(0.8),
# Compare any two Selection and then select the fittest
selection=BinaryTournamentSelection(
MultiComparator(
[FastNonDominatedRanking.get_comparator(),
CrowdingDistance.get_comparator()]
)
),
termination_criterion=StoppingByEvaluations(max=250)
)
algorithm.observable.register(observer=PrintObjectivesObserver(10))