Inconsistent Results in Genetic Programming with Global Random Seed

[billyoftea]

Issue Description

Hi DEAP team,

I'm a beginner using DEAP for genetic programming and have encountered an issue where setting a global random seed (random.seed(1)) does not produce consistent results across multiple runs. Specifically, the results for generation 0 are identical, but starting from generation 1, metrics like average fitness, standard deviation, and number of evaluations differ. I suspect the issue may be related to the selection or crossover processes, as modifying the selRandom function to use a local seed fixed the issue in my tests.

Thank you in advance for your help and for maintaining this amazing library!

Steps to Reproduce

1. Set up a genetic programming experiment with the following configuration:
   • Random seed: random.seed(1), np.random.seed(1), torch.manual_seed(1)
   • Population size: 1000
   • Generations: 3
   • Selection: tools.selTournament with tournsize=20
   • Crossover: gp.cxOnePoint with probability 0.8
   • Mutation: gp.mutUniform with probability 0.3
2. Run the experiment multiple times and compare the output metrics (e.g., average fitness, standard deviation, number of evaluations).
3. Observe that generation 0 metrics are consistent, but subsequent generations differ.

Code Example

Here is the relevant code snippet:

import random
import numpy as np
import torch
from deap import base, creator, tools, gp

# Set random seed
random_state = 1
random.seed(random_state)
np.random.seed(random_state)
torch.manual_seed(random_state)

# Define problem-specific primitives (omitted for brevity)
# Assume pset is a gp.PrimitiveSetTyped object

# Set up DEAP
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", gp.PrimitiveTree, fitness=creator.FitnessMax)

toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=4)
toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
toolbox.register("evaluate", calculate_fitness)  # Custom fitness function (deterministic)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
toolbox.register("mutate", gp.mutUniform, expr=toolbox.expr_mut, pset=pset)
toolbox.register("select", tools.selTournament, tournsize=20)

# Parameters
population_size = 1000
generations = 3
cxpb = 0.8
mutpb = 0.3
hall_of_fame_size = 10

# Run evolution (e.g., using eaSimple)
pop = toolbox.population(n=population_size)
hof = tools.HallOfFame(hall_of_fame_size)
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", np.mean)
stats.register("std", np.std)
stats.register("min", np.min)
stats.register("max", np.max)
pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=cxpb, mutpb=mutpb, ngen=generations, stats=stats, halloffame=hof, verbose=True)

[billyoftea]

Expected Behavior
With random.seed(1) set at the start, I expect the entire evolution process (including selection, crossover, and mutation) to produce identical results across multiple runs, including metrics like average fitness, standard deviation, and number of evaluations for all generations.

Actual Behavior
The metrics for generation 0 (e.g., average fitness, standard deviation, min, max, zero ratio) are identical across runs. However, starting from generation 1, these metrics differ slightly. For example:

First Run:

text

Copy
gen nevals avg std min max zero_ratio time_cost
0 1000 0.00723955 0.0147066 0 0.0593651 0.738 4s
1 852 0.0361427 0.0176558 0 0.0625393 0.1 6s
2 863 0.0487629 0.0194004 0 0.0632971 0.091 8s
3 847 0.0530362 0.0197357 0 0.0665053 0.083 11s
Second Run:

text

Copy
gen nevals avg std min max zero_ratio time_cost
0 1000 0.00723955 0.0147066 0 0.0593651 0.738 4s
1 853 0.0359705 0.0176778 0 0.0625393 0.099 6s
2 879 0.0487505 0.0193488 0 0.065965 0.09 9s
3 844 0.0531704 0.0194802 0 0.0678429 0.089 11s
Investigation and Temporary Fix
I suspect the issue lies in the selection or crossover process, as generation 0 (initial population) is consistent. To narrow it down, I tested modifying the selRandom function to use a local seed:

python

Copy
def selRandom(individuals, k):
old_state = random.getstate()
local_seed = 42
random.seed(local_seed)
result = [random.choice(individuals) for i in range(k)]
random.setstate(old_state)
return result
When I replaced toolbox.register("select", tools.selTournament, tournsize=20) with toolbox.register("select", selRandom) and used this modified function, the results became consistent across runs. This suggests that the random state in the selection process may not be properly managed.

However, my actual code uses tools.selTournament, not selRandom, so I'm unsure if the issue is specific to selRandom or a broader problem with random state handling in DEAP's operators (e.g., tools.selTournament or gp.cxOnePoint).

Questions
Why does setting random.seed(1) at the start not ensure consistent results across runs for all generations?
Is there an issue with the random state management in tools.selTournament or gp.cxOnePoint that could cause this behavior?
Are there recommended practices to ensure reproducibility in DEAP's genetic programming, especially for selection and crossover?

[billyoftea]

The original selRandom is defined as

def selRandom(individuals, k):
    return [random.choice(individuals) for i in range(k)]

what I do to address the issue is
```python
def selRandom(individuals, k):
    old_state = random.getstate()
    
    local_seed = 42 
    random.seed(local_seed)
    result = [random.choice(individuals) for i in range(k)]
    random.setstate(old_state)
    
    return result

[UjwalWtg]

Please set proper seed

import random
import numpy as np
from deap import base, creator, tools

SEED = 42
random.seed(SEED)
np.random.seed(SEED)

[billyoftea]

@UjwalWtg I believe we do it in the same way TAT... I don't understand if there are any differences between the following:
import random
import numpy as np
import torch
from deap import base, creator, tools, gp

Set random seed

random_state = 1
random.seed(random_state)
np.random.seed(random_state)
torch.manual_seed(random_state)

[hkutzy]

The reason why is that about set!!!!!!
The order of items in set is determined by the hash of object, which is determined in python runtime and can be different between different runs. And the deap lib using set in like gp.py in function cxOnePoint(ind1, ind2)
In the implimentation of this function,
`def cxOnePoint(ind1, ind2):
"""Randomly select crossover point in each individual and exchange each
subtree with the point as root between each individual.

:param ind1: First tree participating in the crossover.
:param ind2: Second tree participating in the crossover.
:returns: A tuple of two trees.
"""
if len(ind1) < 2 or len(ind2) < 2:
    # No crossover on single node tree
    return ind1, ind2

# List all available primitive types in each individual
types1 = defaultdict(list)
types2 = defaultdict(list)
if ind1.root.ret == __type__:
    # Not STGP optimization
    types1[__type__] = list(range(1, len(ind1)))
    types2[__type__] = list(range(1, len(ind2)))
    common_types = [__type__]
else:
    for idx, node in enumerate(ind1[1:], 1):
        types1[node.ret].append(idx)
    for idx, node in enumerate(ind2[1:], 1):
        types2[node.ret].append(idx)
    common_types = set(types1.keys()).intersection(set(types2.keys()))

if len(common_types) > 0:
    type_ = random.choice(list(common_types))

    index1 = random.choice(types1[type_])
    index2 = random.choice(types2[type_])

    slice1 = ind1.searchSubtree(index1)
    slice2 = ind2.searchSubtree(index2)
    ind1[slice1], ind2[slice2] = ind2[slice2], ind1[slice1]

return ind1, ind2`

do you note that "common_types = set(types1.keys()).intersection(set(types2.keys()))" and type_ = random.choice(list(common_types))？
common_types will be of different order in different runs and type_ = random.choice(list(common_types)) will generate different type_ and index1 and index2 will be different, that's how seed cannot help. Personally, I hacked the code here, alter the set into a list and sort by str(type) and the code run smoothly now.

[hkutzy]

@UjwalWtg I believe we do it in the same way TAT... I don't understand if there are any differences between the following: import random import numpy as np import torch from deap import base, creator, tools, gp

Set random seed

random_state = 1 random.seed(random_state) np.random.seed(random_state) torch.manual_seed(random_state)

I've just noted that we were from a same school