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)