def test_genome_reordering_parameterization_consistency(rng):
genome_params = {
"n_inputs": 2,
"n_outputs": 1,
"n_columns": 10,
"n_rows": 2,
"primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat),
}
genome = cgp.Genome(**genome_params)
with pytest.raises(ValueError):
genome.reorder(rng)
genome_params = {
"n_inputs": 2,
"n_outputs": 1,
"n_columns": 10,
"n_rows": 1,
"primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat),
"levels_back": 5,
}
genome = cgp.Genome(**genome_params)
with pytest.raises(ValueError):
genome.reorder(rng)
def test_change_address_gene_of_output_node(genome_params, rng):
genome = cgp.Genome(**genome_params)
genome.randomize(rng)
with pytest.raises(ValueError):
genome.change_address_gene_of_output_node(new_address=-1,
output_node_idx=0)
genome.change_address_gene_of_output_node(new_address=10,
output_node_idx=0)
genome.change_address_gene_of_output_node(new_address=0,
output_node_idx=1)
for new_address in range(9):
genome.change_address_gene_of_output_node(new_address)
assert genome.dna[-2] == new_address
genome_params["n_outputs"] = 2
genome = cgp.Genome(**genome_params)
genome.randomize(rng)
new_address = 2
genome.change_address_gene_of_output_node(new_address, output_node_idx=0)
assert genome.dna[-5] == new_address
genome.change_address_gene_of_output_node(new_address, output_node_idx=1)
assert genome.dna[-2] == new_address
def test_to_func_simple():
primitives = (cgp.Add, )
genome = cgp.Genome(2, 1, 1, 1, primitives)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
f = graph.to_func()
x = [5.0, 2.0]
y = f(*x)
assert x[0] + x[1] == pytest.approx(y)
primitives = (cgp.Sub, )
genome = cgp.Genome(2, 1, 1, 1, primitives)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
f = graph.to_func()
x = [5.0, 2.0]
y = f(*x)
assert x[0] - x[1] == pytest.approx(y)
def test_parameter_two_nodes():
genome_params = {
"n_inputs": 1,
"n_outputs": 1,
"n_columns": 3,
"n_rows": 1,
}
primitives = (cgp.Parameter, cgp.Add)
genome = cgp.Genome(**genome_params, primitives=primitives)
# f(x) = c1 + c2
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
0,
0,
0,
0,
1,
1,
2,
ID_OUTPUT_NODE,
3,
ID_NON_CODING_GENE,
]
x = [1.0]
# by default the output value of the Parameter node is 1.0,
# hence the sum of two Parameter nodes is 2.0
y_target = 2.0
_test_to_x_compilations(genome, x, y_target)
def test_constant_float():
params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1}
primitives = (cgp.ConstantFloat, )
# f(x) = c
genome = cgp.Genome(
params["n_inputs"],
params["n_outputs"],
params["n_columns"],
params["n_rows"],
primitives,
)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
ID_OUTPUT_NODE,
2,
]
x = [1.0, 2.0]
y_target = 1.0 # by default the output value of the ConstantFloat node is 1.0
_test_to_x_compilations(genome, x, y_target)
def test_permissible_values(genome_params):
n_inputs = 2
n_outputs = 1
n_columns = 3
n_rows = 3
levels_back = 2
primitives = (cgp.Add, cgp.Sub, cgp.ConstantFloat)
genome = cgp.Genome(n_inputs, n_outputs, n_columns, n_rows, primitives,
levels_back)
permissible_function_gene_values = np.arange(
len(genome._primitives._primitives))
permissible_addresses_first_internal_column = np.array([0, 1])
permissible_addresses_second_internal_column = np.array([0, 1, 2, 3, 4])
permissible_addresses_third_internal_column = np.array(
[0, 1, 2, 3, 4, 5, 6, 7])
permissible_addresses_output = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
permissible_values_expected = [
np.array(ID_INPUT_NODE),
np.array(ID_NON_CODING_GENE),
np.array(ID_NON_CODING_GENE),
np.array(ID_INPUT_NODE),
np.array(ID_NON_CODING_GENE),
np.array(ID_NON_CODING_GENE),
permissible_function_gene_values,
permissible_addresses_first_internal_column,
permissible_addresses_first_internal_column,
permissible_function_gene_values,
permissible_addresses_first_internal_column,
permissible_addresses_first_internal_column,
permissible_function_gene_values,
permissible_addresses_first_internal_column,
permissible_addresses_first_internal_column,
permissible_function_gene_values,
permissible_addresses_second_internal_column,
permissible_addresses_second_internal_column,
permissible_function_gene_values,
permissible_addresses_second_internal_column,
permissible_addresses_second_internal_column,
permissible_function_gene_values,
permissible_addresses_second_internal_column,
permissible_addresses_second_internal_column,
permissible_function_gene_values,
permissible_addresses_third_internal_column,
permissible_addresses_third_internal_column,
permissible_function_gene_values,
permissible_addresses_third_internal_column,
permissible_addresses_third_internal_column,
permissible_function_gene_values,
permissible_addresses_third_internal_column,
permissible_addresses_third_internal_column,
np.array(ID_OUTPUT_NODE),
permissible_addresses_output,
np.array(ID_NON_CODING_GENE),
]
for (pv_per_gene_expected, pv_per_gene) in zip(permissible_values_expected,
genome._permissible_values):
assert np.all(pv_per_gene_expected == pv_per_gene)
def test_pretty_str():
primitives = (cgp.Sub, cgp.Mul)
genome = cgp.Genome(1, 1, 2, 1, primitives, 1)
# x[0] ** 2
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
0,
1,
0,
0,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
pretty_str = graph.pretty_str()
for node in graph.input_nodes:
assert node.__class__.__name__ in pretty_str
for node in graph.output_nodes:
assert node.__class__.__name__ in pretty_str
for node in graph.hidden_nodes:
assert node.__class__.__name__ in pretty_str
def test_to_numpy():
primitives = (cgp.Add, cgp.Mul, cgp.ConstantFloat)
genome = cgp.Genome(1, 1, 2, 2, primitives, 1)
# f(x) = x ** 2 + 1.
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
2,
0,
0,
1,
0,
0,
0,
1,
2,
0,
0,
1,
ID_OUTPUT_NODE,
3,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
f = graph.to_numpy()
x = np.random.normal(size=100)
y = f(x)
y_target = x**2 + 1.0
assert y == pytest.approx(y_target)
def test_add():
params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1}
primitives = (cgp.Add, )
genome = cgp.Genome(
params["n_inputs"],
params["n_outputs"],
params["n_columns"],
params["n_rows"],
primitives,
)
# f(x) = x[0] + x[1]
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
x = [5.0, 1.5]
y_target = x[0] + x[1]
_test_to_x_compilations(genome, x, y_target)
def test_mul():
params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1, "levels_back": 1}
primitives = (cgp.Mul,)
genome = cgp.Genome(
params["n_inputs"],
params["n_outputs"],
params["n_columns"],
params["n_rows"],
params["levels_back"],
primitives,
)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
x = [5.0, 1.5]
y = graph(x)
assert x[0] * x[1] == pytest.approx(y[0])
def test_constant_float():
params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1, "levels_back": 1}
primitives = (cgp.ConstantFloat,)
genome = cgp.Genome(
params["n_inputs"],
params["n_outputs"],
params["n_columns"],
params["n_rows"],
params["levels_back"],
primitives,
)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
ID_OUTPUT_NODE,
2,
]
graph = cgp.CartesianGraph(genome)
x = [None, None]
y = graph(x)
# by default the output value of the ConstantFloat node is 1.0
assert 1.0 == pytest.approx(y[0])
def test_update_parameters_from_torch_class_does_not_reset_fitness_for_unused_parameters(
individual_type,
):
pytest.importorskip("torch")
primitives = (cgp.Mul, cgp.Parameter)
genome = cgp.Genome(1, 1, 2, 1, primitives, 1)
# f(x) = x ** 2
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
1, # these
0, # three
0, # genes code for an unused parameter node
0,
0,
0,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
fitness = 1.0
individual = _create_individual(genome, fitness=fitness, individual_type=individual_type)
f = individual.to_torch()
assert not individual.fitness_is_None()
individual.update_parameters_from_torch_class(f)
assert not individual.fitness_is_None()
g = _unpack_evaluation(individual.to_func(), individual_type)
x = 2.0
assert g(x) == pytest.approx(x ** 2)
def test_update_parameters_from_torch_class_resets_fitness(individual_type):
pytest.importorskip("torch")
primitives = (cgp.Mul, cgp.Parameter)
genome = cgp.Genome(1, 1, 2, 1, primitives, 1)
# f(x) = c * x
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
1,
0,
0,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
fitness = 1.0
individual = _create_individual(genome, fitness=fitness, individual_type=individual_type)
f = individual.to_torch()
f_opt = _unpack_evaluation(f, individual_type=individual_type)
f_opt._p1.data[0] = math.pi
assert not individual.fitness_is_None()
individual.update_parameters_from_torch_class(f)
assert individual.fitness_is_None()
g = _unpack_evaluation(individual.to_func(), individual_type)
x = 2.0
assert g(x) == pytest.approx(math.pi * x)
def test_convergence_to_maximum(rng_seed):
primitives = (cgp.Parameter, )
genome = cgp.Genome(1, 2, 2, 1, primitives)
# [f0(x), f1(x)] = [c1, c2]
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
0,
0,
ID_OUTPUT_NODE,
1,
ID_OUTPUT_NODE,
2,
]
ind = cgp.individual.IndividualSingleGenome(genome)
ind.idx = 0
# single process
ind.genome._parameter_names_to_values["<p1>"] = 0.85
ind.genome._parameter_names_to_values["<p2>"] = 0.95
es = cgp.local_search.EvolutionStrategies(
_objective_convergence_to_maximum, rng_seed, max_steps=60)
es(ind)
assert ind.genome._parameter_names_to_values["<p1>"] == pytest.approx(1.0)
assert ind.genome._parameter_names_to_values["<p2>"] == pytest.approx(1.1)
def test_update_parameters_from_torch_class_does_not_reset_fitness_for_unused_parameters():
pytest.importorskip("torch")
primitives = (cgp.Mul, cgp.Parameter)
genome = cgp.Genome(1, 1, 2, 1, 1, primitives)
# f(x) = x ** 2
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
1, # these
0, # three
0, # genes code for an unused parameter node
0,
0,
0,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
fitness = 1.0
individual = IndividualSingleGenome(fitness, genome)
f = individual.to_torch()
assert individual.fitness is not None
individual.update_parameters_from_torch_class(f)
assert individual.fitness is not None
g = individual.to_func()
x = 2.0
assert g([x])[0] == pytest.approx(x ** 2)
def test_reset_parameters_upon_creation_of_node(rng):
class CustomParameter(cgp.Parameter):
_initial_values = {"<p>": lambda: np.pi}
genome_params = {
"n_inputs": 1,
"n_outputs": 1,
"n_columns": 1,
"n_rows": 1,
}
primitives = (CustomParameter, CustomParameter)
genome = cgp.Genome(**genome_params, primitives=primitives)
# f(x) = p
genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1]
genome._parameter_names_to_values["<p1>"] = 1.0
f = cgp.CartesianGraph(genome).to_func()
y = f(0.0)
assert y == pytest.approx(1.0)
# now mutate the genome, since there is only one other option for
# the hidden node, a new CustomParameter node will be created;
# creating this new node should reset the parameter to its initial
# value; after mutation we recreate the correct graph connectivity
# manually
genome.mutate(1.0, rng)
# f(x) = p
genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1]
f = cgp.CartesianGraph(genome).to_func()
y = f(0.0)
assert y == pytest.approx(np.pi)
def test_splice_dna(genome_params, rng):
genome = cgp.Genome(**genome_params)
with pytest.raises(RuntimeError):
genome.splice_dna(new_dna=[1, 2, 3])
genome.randomize(rng)
new_dna = []
with pytest.raises(ValueError):
[] = genome.splice_dna(new_dna)
new_dna = [0, 0, 1]
with pytest.raises(ValueError):
[] = genome.splice_dna(new_dna, hidden_start_node=-1)
with pytest.raises(ValueError):
[] = genome.splice_dna(new_dna,
hidden_start_node=9) # only 9 internal nodes
address_node = genome.splice_dna(new_dna)
assert address_node == 2 # 0 + n_inputs
address_node = genome.splice_dna(new_dna, hidden_start_node=2)
assert address_node == 4 # 2 + n_inputs
dna_insert = [0, 0, 1, 1, 1, 1]
address_node = genome.splice_dna(dna_insert)
assert address_node == 3 # 1 + n_inputs
dna_insert = [0, 0, 1, 0]
with pytest.raises(ValueError):
[] = genome.splice_dna(dna_insert)
def test_gradient_based_step_towards_maximum():
torch = pytest.importorskip("torch")
primitives = (cgp.Parameter, )
genome = cgp.Genome(1, 1, 1, 1, primitives)
# f(x) = c
genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1]
ind = cgp.individual.IndividualSingleGenome(genome)
def objective(f):
x_dummy = torch.zeros((1, 1), dtype=torch.double) # not used
target_value = torch.ones((1, 1), dtype=torch.double)
return torch.nn.MSELoss()(f(x_dummy), target_value)
# test increase parameter value if too small
ind.genome._parameter_names_to_values["<p1>"] = 0.9
cgp.local_search.gradient_based(ind, objective, 0.05, 1)
assert ind.genome._parameter_names_to_values["<p1>"] == pytest.approx(0.91)
# test decrease parameter value if too large
ind.genome._parameter_names_to_values["<p1>"] = 1.1
cgp.local_search.gradient_based(ind, objective, 0.05, 1)
assert ind.genome._parameter_names_to_values["<p1>"] == pytest.approx(1.09)
# test no change of parameter value if at optimum
ind.genome._parameter_names_to_values["<p1>"] = 1.0
cgp.local_search.gradient_based(ind, objective, 0.05, 1)
assert ind.genome._parameter_names_to_values["<p1>"] == pytest.approx(1.0)
def test_primitives_from_class_names_for_genome(genome_params):
primitives_str = ("Add", "Sub", "Mul")
primitives = cgp.utils.primitives_from_class_names(primitives_str)
genome_params["primitives"] = primitives
cgp.Genome(**genome_params)
def test_allow_sympy_expr_with_infinities():
pytest.importorskip("sympy")
primitives = (cgp.Sub, cgp.Div)
genome = cgp.Genome(1, 1, 2, 1, primitives, 1)
# x[0] / (x[0] - x[0])
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
0,
1,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
expr = graph.to_sympy(simplify=True)
# complex infinity should appear in expression
assert "zoo" in str(expr)
def test_fec_cache_decorator_with_additional_arguments(genome_params, rng,
rng_seed):
def f_target(x):
return x[:, 0] - x[:, 1]
@cgp.utils.disk_cache(
tempfile.mkstemp()[1],
compute_key=cgp.utils.compute_key_from_numpy_evaluation_and_args)
def inner_objective(ind, n_samples):
f = ind.to_func()
rng_objective = np.random.RandomState(seed=rng_seed)
x = rng_objective.uniform(size=(n_samples, 2))
loss = np.sum((f(x[:, 0], x[:, 1]) - f_target(x))**2)
return loss
g = cgp.Genome(**genome_params)
g.randomize(rng)
ind = cgp.IndividualSingleGenome(g)
# call with 5 and 10 samples, results should be different since
# the second call should *not* return the cached value
y0 = inner_objective(ind, 5)
y1 = inner_objective(ind, 10)
assert y0 != pytest.approx(y1)
def test_compile_two_columns():
primitives = (cgp.Add, cgp.Sub)
genome = cgp.Genome(2, 1, 2, 1, primitives, 1)
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
0,
0,
1,
1,
0,
2,
ID_OUTPUT_NODE,
3,
ID_NON_CODING_GENE,
]
graph = cgp.CartesianGraph(genome)
f = graph.to_func()
x = [5.0, 2.0]
y = f(*x)
assert x[0] - (x[0] + x[1]) == pytest.approx(y)
def test_parameter_w_random_initial_value(rng_seed):
np.random.seed(rng_seed)
min_val = 0.5
max_val = 1.5
class CustomParameter(cgp.Parameter):
_initial_values = {"<p>": lambda: np.random.uniform(min_val, max_val)}
genome_params = {
"n_inputs": 1,
"n_outputs": 1,
"n_columns": 1,
"n_rows": 1,
}
primitives = (CustomParameter, )
genome = cgp.Genome(**genome_params, primitives=primitives)
# f(x) = c
genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1]
f = cgp.CartesianGraph(genome).to_func()
y = f(0.0)
assert min_val <= y
assert y <= max_val
assert y != pytest.approx(1.0)
def test_is_gene_in_output_region(rng_seed):
genome = cgp.Genome(2, 1, 2, 1, (cgp.Add, ))
rng = np.random.RandomState(rng_seed)
genome.randomize(rng)
assert genome._is_gene_in_output_region(12)
assert not genome._is_gene_in_output_region(11)
def test_multiple_parameters_per_node():
p = 3.1415
q = 2.7128
class DoubleParameter(cgp.OperatorNode):
_arity = 0
_initial_values = {"<p>": lambda: p, "<q>": lambda: q}
_def_output = "<p> + <q>"
_def_numpy_output = "np.ones(len(x[0])) * (<p> + <q>)"
_def_torch_output = "torch.ones(1).expand(x.shape[0]) * (<p> + <q>)"
genome_params = {
"n_inputs": 1,
"n_outputs": 1,
"n_columns": 1,
"n_rows": 1,
}
primitives = (DoubleParameter, )
genome = cgp.Genome(**genome_params, primitives=primitives)
# f(x) = p + q
genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1]
f = cgp.CartesianGraph(genome).to_func()
y = f(0.0)
assert y == pytest.approx(p + q)
def test_parameters_numpy_array_consistency():
primitives = (cgp.Parameter, )
genome = cgp.Genome(1, 1, 2, 1, primitives)
# [f0(x), f1(x)] = [c1, c2]
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
0,
0,
ID_OUTPUT_NODE,
1,
]
genome._parameter_names_to_values["<p1>"] = 0.8
genome._parameter_names_to_values["<p2>"] = 0.9
genome.update_parameters_from_numpy_array(
*genome.parameters_to_numpy_array())
assert genome._parameter_names_to_values["<p1>"] == pytest.approx(0.8)
assert genome._parameter_names_to_values["<p2>"] == pytest.approx(0.9)
genome._parameter_names_to_values["<p1>"] = 1.1
genome._parameter_names_to_values["<p2>"] = 1.2
genome.update_parameters_from_numpy_array(
*genome.parameters_to_numpy_array(only_active_nodes=True))
assert genome._parameter_names_to_values["<p1>"] == pytest.approx(1.1)
assert genome._parameter_names_to_values["<p2>"] == pytest.approx(1.2)
def test_update_parameters_from_torch_class_resets_fitness():
pytest.importorskip("torch")
primitives = (cgp.Mul, cgp.Parameter)
genome = cgp.Genome(1, 1, 2, 1, 1, primitives)
# f(x) = c * x
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
ID_NON_CODING_GENE,
1,
0,
0,
0,
0,
1,
ID_OUTPUT_NODE,
2,
ID_NON_CODING_GENE,
]
fitness = 1.0
individual = IndividualSingleGenome(fitness, genome)
f = individual.to_torch()
f._p1.data[0] = math.pi
assert individual.fitness is not None
individual.update_parameters_from_torch_class(f)
assert individual.fitness is None
g = individual.to_func()
x = 2.0
assert g([x])[0] == pytest.approx(math.pi * x)
def test_parameters_to_numpy_array():
primitives = (cgp.Parameter, )
genome = cgp.Genome(1, 1, 2, 1, primitives)
# [f0(x), f1(x)] = [c1, c2]
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
0,
0,
ID_OUTPUT_NODE,
1,
]
genome._parameter_names_to_values["<p1>"] = 0.8
genome._parameter_names_to_values["<p2>"] = 0.9
# all parameters
expected_params = np.array([0.8, 0.9])
expected_params_names = ["<p1>", "<p2>"]
params, params_names = genome.parameters_to_numpy_array()
assert np.all(params == pytest.approx(expected_params))
assert params_names == expected_params_names
# only parameters of active nodes
expected_params = np.array([0.8])
expected_params_names = ["<p1>"]
params, params_names = genome.parameters_to_numpy_array(
only_active_nodes=True)
assert np.all(params == pytest.approx(expected_params))
def test_update_parameters_from_numpy_array():
primitives = (cgp.Parameter, )
genome = cgp.Genome(1, 1, 2, 1, primitives)
# [f0(x), f1(x)] = [c1, c2]
genome.dna = [
ID_INPUT_NODE,
ID_NON_CODING_GENE,
0,
0,
0,
0,
ID_OUTPUT_NODE,
1,
]
params = np.array([0.8, 0.9])
params_names = ["<p1>", "<p2>"]
any_parameter_changed = genome.update_parameters_from_numpy_array(
params, params_names)
assert any_parameter_changed
assert genome._parameter_names_to_values["<p1>"] == pytest.approx(0.8)
assert genome._parameter_names_to_values["<p2>"] == pytest.approx(0.9)
# parameters do not change value
any_parameter_changed = genome.update_parameters_from_numpy_array(
params, params_names)
assert not any_parameter_changed
assert genome._parameter_names_to_values["<p1>"] == pytest.approx(0.8)
assert genome._parameter_names_to_values["<p2>"] == pytest.approx(0.9)
def test_is_gene_in_hidden_region(rng):
genome = cgp.Genome(2, 1, 2, 1, (cgp.Add, ))
genome.randomize(rng)
assert genome._is_gene_in_hidden_region(6)
assert genome._is_gene_in_hidden_region(9)
assert not genome._is_gene_in_hidden_region(5)
assert not genome._is_gene_in_hidden_region(12)
