Caculating the total number of fitness function calls

[TiMo3654]

Based on my understanding so far, one can calculate the number of total fitness function calls by multiplying the number of solutions per population with the number of generations plus the function calls for an initial population.

So with a sol_per_pop = 50 and num_generations = 20, I would expect 50 + 21 *49 = 1079 fitness function calls in total.

But by printing a message every time the fitness function is called, I noticed that the total count amounts to 2059 function calls.

In another case, the object returned 8 completed generations and the cost function was called 932 times not my expected 491 times.

My implementation is like this:

num_parents_mating      = 4

sol_per_pop             = 50
num_genes               = 10

init_range_low          = 0
init_range_high         = 1

parent_selection_type   = "sss"
keep_parents            = 1

crossover_type          = "single_point"

mutation_type           = "random"
mutation_percent_genes  = 10

gene_space              = {'low' :  0, 'high':   1}

def check_for_termination(ga_instance):  
     if ga_instance.best_solution()[1] == np.float64(-0.0):
        return "stop"

def genetic_optimizer(fun, num_generations):
    ga_instance = pygad.GA(num_generations=num_generations,
                       num_parents_mating=num_parents_mating,
                       fitness_func=fun,
                       sol_per_pop=sol_per_pop,
                       num_genes=num_genes,
                       init_range_low=init_range_low,
                       init_range_high=init_range_high,
                       parent_selection_type=parent_selection_type,
                       keep_parents=keep_parents,
                       crossover_type=crossover_type,
                       mutation_type=mutation_type,
                       mutation_percent_genes=mutation_percent_genes,
                       gene_space = gene_space,
                       callback_generation= check_for_termination)
    
    ga_instance.run()

    solution, solution_fitness, solution_idx = ga_instance.best_solution()

    num_completed_generations = ga_instance.generations_completed

    print('Completed Generation: ' + str(num_completed_generations))

    return solution_fitness, solution, num_completed_generations

Any help, on how to calculate the total number of function calls is greatly appreciated or why I might see different call numbers than exspected.

[ahmedfgad]

Hi @TiMo3654,

The reason for doubling the number of calls to the fitness function is calling the best_solution() method in the generation callback function.

def check_for_termination(ga_instance):  
     if ga_instance.best_solution()[1] == np.float64(-0.0):
        return "stop"

When this method is called without passing the pop_fitness parameter, then it works as by calculating the fitness of the current population by calling the fitness function.

As you have 50 solutions, then one call to the best_solution() method makes 50 calls to the fitness function. For 20 generations, then it makes 50*20 calls. So, the overall total number of calls is 50*20 + 50*20 + 50 = 2050.

In PyGAD, the fitness of the current population is already calculated and saved in the last_generation_fitness instance attribute. You can pass it to the pop_fitness parameter. This is the new callback function.

def check_for_termination(ga_instance):  
     if ga_instance.best_solution(pop_fitness=ga_instance.last_generation_fitness)[1] == np.float64(-0.0):
        return "stop"

Hope this helps. Please let me know if you have any other questions.