def execute_iterated(self, board, genetic_steps, hierarchical_steps = 10):

        first_boards = fill_steps(board, steps = 3)

        top_solution_boards = first_boards

        for i in range(hierarchical_steps):

            boards = top_solution_boards[:self.population_size]

            population = []
            for b in boards:
                population.extend(generate_population(b, self.population_size // len(boards)))

            population.extend(generate_population(boards[-1], self.population_size % len(boards)))

            (output_population, solution) = self.genetic.execute(population=population, steps=genetic_steps)

            if solution != None:
                return (output_population, solution)
            sort_by_fitness = lambda p: p.fitness if p.fitness is not None else 100
            top_solutions = sorted(output_population, key=sort_by_fitness, reverse = True)[:50]

            top_solutions_boards = [g.board.copy() for g in top_solutions]
            # Leave just the invariants
            for b in top_solutions_boards:
                for (r, row) in enumerate(b):
                    for (c, col) in enumerate(row):
                        b[r,c] = 0
                b.fix_invariants()
            top_solution_boards.extend(boards)

        return (output_population, solution)
    def execute(self, board, genetic_steps):

        boards = fill_steps(board, steps = 4)

        boards = boards[:self.population_size]

        population = []
        for b in boards:
            population.extend(generate_population(b, self.population_size // len(boards)))

        population.extend(generate_population(boards[-1], self.population_size % len(boards)))
        
        (output_population, solution) = self.genetic.execute(population=population, steps=genetic_steps)

        return (output_population, solution)
Example #3
0
genetic_operations = GeneticOperations(evaluate, generators, creator, target)

min_population = 100

max_population = 200

num_iterations = 5000

mutation_probability = 0.3

selection_probability = 0.4

limit = 100

population = generate_population(genetic_operations, min_population)

for i in tqdm(range(10)):
    population = main_algorithm(population, min_population, max_population,
                                num_iterations, limit, genetic_operations,
                                mutation_probability, selection_probability)
    limit *= 10

solutions = [individual.values[0:variables_count] for individual in population]

print()

print('best solution', solutions[0])

print('score', population[0].score)
    # print configuration for the current invocation
    rows, cols = board.shape()
    board_fill = sum(1 for r in range(rows) for c in range(cols) if board[r, c] != 0)

    print(
        population_size,
        configuration["number_of_tournaments"],
        configuration["tournament_size"],
        configuration["mutation_probability"],
        board_fill,
    )

    genetic_steps = configuration["genetic_steps"]
    if configuration["use_genetic_only"]:
        population = generate_population(board, population_size)
        output_population, solution = genetic_algorithm.execute(population, genetic_steps)
    else:
        hierarchical_algorithm = HierarchicalAlgorithm(genetic_algorithm, population_size)
        output_population, solution = hierarchical_algorithm.execute_iterated(board, genetic_steps=genetic_steps)

    print("=" * 100, file=sys.stderr)
    print("5 best boards:", file=sys.stderr)
    sort_by_fitness = lambda p: p.fitness if p.fitness is not None else 100
    for p in sorted(output_population, key=sort_by_fitness, reverse=True)[-5:]:
        print(p.board, p.fitness, file=sys.stderr)
        print(file=sys.stderr)

    print("=" * 100, file=sys.stderr)
    print("Initial board:\n{0}\n".format(board), file=sys.stderr)