def check_samples(samples: List[Tuple[np.ndarray, float]],
benchmark: Benchmark):
for genome, fitness in samples:
solution = Solution(np.array(genome))
pred_fitness = benchmark.evaluate_solution(solution)
assert isinstance(pred_fitness, float)
assert pred_fitness == fitness
def fix(self, solution: Solution) -> Solution:
genome = solution.genome.copy()
mask = genome > self.upper_bound
genome[mask] = self.upper_bound[mask]
mask = genome < self.lower_bound
genome[mask] = self.lower_bound[mask]
return Solution(genome)
def test_fix():
trap = Trap(blocks=[3])
genome = np.array([0, 1, 2])
solution = Solution(genome)
solution = trap.fix(solution)
assert isinstance(solution, Solution)
assert isinstance(solution.genome, np.ndarray)
assert list(solution.genome) == [0, 1, 1]
def _evaluate_solution(self, solution: Solution) -> float:
index = 0
fitness = 0
for benchmark in self.benchmarks:
sub_solution = solution.genome[index:index + benchmark.genome_size]
sub_solution = Solution(sub_solution)
fitness += benchmark._evaluate_solution(sub_solution)
index += benchmark.genome_size
return fitness
def random_solutions(self, population_size: int) -> List[Solution]:
populations = []
for benchmark in self.benchmarks:
population = benchmark.initialize_population(population_size)
populations.append(population.as_ndarray)
genomes = np.concatenate(populations, axis=1)
if self.USE_SHUFFLE:
genomes = shuffle(genomes, self.gene_order)
return list(Solution(genome) for genome in genomes)
def random_solutions(self, population_size: int) -> List[Solution]:
genomes = self.random_state.uniform(low=0,
high=1,
size=(population_size,
self.genome_size))
genomes *= self.bound_range
genomes += self.lower_bound
if self.USE_SHUFFLE:
genomes = shuffle(genomes, self.gene_order)
return list(Solution(genome) for genome in genomes)
def print_route(self, solution: Solution):
phenome = self.get_phenome(solution)
sub_routes = self.get_sub_routes(phenome)
for index, route in enumerate(sub_routes):
sub_route = [self.config.depot, *route, self.config.depot]
sub_route_genome = [node.id for node in sub_route]
sub_route_genome = np.array(sub_route_genome)
sub_route_solution = Solution(sub_route_genome)
length = self._evaluate_solution(sub_route_solution)
cargo = sum([node.demand for node in sub_route])
print(f"Route {index}")
print(f"Length: {length:.0f}, Cargo: {cargo}")
print(f"Nodes: {[node.id for node in route]}\n")
def random_solutions(self, population_size: int) -> List[Solution]:
target_nodes_idx = [node.id for node in self.config.target_nodes]
max_id = max(target_nodes_idx)
n = len(target_nodes_idx)
depots = range(max_id + 1, max_id + self.genome_size - n + 1)
nodes_idx = target_nodes_idx + list(depots)
genomes = []
for _ in range(population_size):
genome = self.random_state.permutation(nodes_idx)
genomes.append(genome)
genomes = np.array(genomes)
if self.USE_SHUFFLE:
genomes = shuffle(genomes, self.gene_order)
return list(Solution(genome) for genome in genomes)
def deshuffle_solution(solution: Solution, gene_order: List[int]) -> Solution:
deshuffled = deshuffle(solution.genome, gene_order)
return Solution(deshuffled)
def fix(self, solution: Solution) -> Solution:
solution = super(Discrete, self).fix(solution)
genome = solution.genome.astype(dtype=int)
return Solution(genome)