From 37a830fd97c04de66adbceb015e21fe02a6298e6 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:45:54 +0100 Subject: [PATCH 01/12] remove n_rows and levels_back in genome --- cgp/genome.py | 49 ++++++++++--------------------------------------- 1 file changed, 10 insertions(+), 39 deletions(-) diff --git a/cgp/genome.py b/cgp/genome.py index db72b9be..9f4161b9 100644 --- a/cgp/genome.py +++ b/cgp/genome.py @@ -29,9 +29,7 @@ def __init__( n_inputs: int = 1, n_outputs: int = 1, n_columns: int = 128, - n_rows: int = 1, primitives: Optional[Tuple[Type[Node], ...]] = None, - levels_back: Optional[int] = None, ) -> None: """Init function. @@ -43,13 +41,8 @@ def __init__( Number of outputs of the function represented by the genome. Defaults to 1. n_columns : int, optional Number of columns in the representation of the genome. Defaults to 12. - n_rows : int, optional - Number of rows in the representation of the genome. Defaults to 1. primitives : Tuple[Type[Node], ...], optional Tuple of primitives that the genome can refer to. Defaults to (+, -, *, 1.0). - levels_back : Optional[int], optional - Maximal column distance of inputs to an internal node. If - set to `None`, no restrictions are used. Defaults to None. """ if n_inputs <= 0: @@ -60,22 +53,10 @@ def __init__( raise ValueError("n_columns must be non-negative") self._n_columns = n_columns - if n_rows < 0: - raise ValueError("n_rows must be non-negative") - self._n_rows = n_rows - if n_outputs <= 0: raise ValueError("n_outputs must be strictly positive") self._n_outputs = n_outputs - if levels_back is None: - levels_back = n_columns - if levels_back == 0 and n_columns != 0: - raise ValueError("levels_back must be strictly positive") - if levels_back > n_columns: - raise ValueError("levels_back can not be larger than n_columns") - self._levels_back = levels_back - if primitives is None: # we need to delay this import to avoid circular imports: node_impl # -> node -> node_validation -> genome @@ -128,7 +109,7 @@ def dna(self, value: List[int]) -> None: @property def _n_hidden(self) -> int: - return self._n_columns * self._n_rows + return self._n_columns @property def _n_regions(self) -> int: @@ -267,9 +248,7 @@ def randomize(self, rng: np.random.RandomState) -> None: # add hidden nodes for i in range(self._n_hidden): - if i % self._n_rows == 0: # only compute permissible addresses once per column - permissible_addresses = self._permissible_addresses(i + self._n_inputs) - + permissible_addresses = self._permissible_addresses(i + self._n_inputs) dna += self._create_random_hidden_region(rng, permissible_addresses) # add output nodes @@ -312,7 +291,7 @@ def splice_dna(self, new_dna: List[int], hidden_start_node: int = 0) -> int: if hidden_start_node < 0 or hidden_start_node > self._n_hidden: raise ValueError("hidden_start_node must be non-negative and smaller than n_hidden") - if hidden_start_node + n_inserted_nodes >= self._n_hidden: + if hidden_start_node + n_inserted_nodes > self._n_hidden: raise ValueError("New dna too long") dna = self.dna @@ -409,10 +388,6 @@ def reorder(self, rng: np.random.RandomState) -> None: ---------- None """ - if (self._n_rows != 1) or (self._levels_back != self._n_columns): - raise ValueError( - "Genome reordering is only implemented for n_rows=1" " and levels_back=n_columns" - ) dna = self._dna.copy() @@ -501,9 +476,7 @@ def _update_address_genes(self, dna: List[int], used_node_indices: List[int]) -> def _replace_invalid_address_alleles(self, dna: List[int], rng: np.random.RandomState) -> None: """Replace invalid alleles for unused address genes of all nodes by random permissible values. - WARNING: Works only if self.n_rows==1. """ - assert self._n_rows == 1 for gene_idx, gene_value in enumerate(dna): region_idx = self._get_region_idx(gene_idx) @@ -578,22 +551,22 @@ def _permissible_addresses(self, region_idx: int) -> List[int]: # all nodes can be connected to input permissible_addresses += [j for j in range(0, self._n_inputs)] - # add all nodes reachable according to levels back + # add all nodes reachable if self._is_hidden_region(region_idx): hidden_column_idx = self._hidden_column_idx(region_idx) - lower = self._n_inputs + self._n_rows * max(0, (hidden_column_idx - self._levels_back)) - upper = self._n_inputs + self._n_rows * hidden_column_idx + lower = self._n_inputs + upper = self._n_inputs + hidden_column_idx else: assert self._is_output_region(region_idx) lower = self._n_inputs - upper = self._n_inputs + self._n_rows * self._n_columns + upper = self._n_inputs + self._n_columns permissible_addresses += [j for j in range(lower, upper)] return permissible_addresses def _permissible_addresses_for_output_region(self) -> List[int]: - return self._permissible_addresses(self._n_inputs + self._n_rows * self._n_columns) + return self._permissible_addresses(self._n_inputs + self._n_columns) def _validate_dna(self, dna: List[int]) -> None: @@ -637,8 +610,8 @@ def _validate_dna(self, dna: List[int]) -> None: def _hidden_column_idx(self, region_idx: int) -> int: assert self._n_inputs <= region_idx - assert region_idx < self._n_inputs + self._n_rows * self._n_columns - hidden_column_idx = (region_idx - self._n_inputs) // self._n_rows + assert region_idx < self._n_inputs + self._n_columns + hidden_column_idx = (region_idx - self._n_inputs) assert 0 <= hidden_column_idx assert hidden_column_idx < self._n_columns return hidden_column_idx @@ -791,9 +764,7 @@ def clone(self) -> "Genome": self._n_inputs, self._n_outputs, self._n_columns, - self._n_rows, tuple(self._primitives), - self._levels_back, ) new.dna = self.dna.copy() From cc2f791e5efa2b712a25efe2da0f58c584e9337e Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:47:00 +0100 Subject: [PATCH 02/12] remove n_rows in cartesian graph --- cgp/cartesian_graph.py | 36 +++++++++++------------------------- 1 file changed, 11 insertions(+), 25 deletions(-) diff --git a/cgp/cartesian_graph.py b/cgp/cartesian_graph.py index 3cab1afc..bdfc1c00 100644 --- a/cgp/cartesian_graph.py +++ b/cgp/cartesian_graph.py @@ -53,7 +53,6 @@ def __init__(self, genome: "Genome") -> None: self._n_inputs: int self._n_outputs: int self._n_columns: int - self._n_rows: int self._nodes: List self._parameter_names_to_values: Dict[str, float] @@ -82,29 +81,17 @@ def empty_node_str() -> str: s = "\n" - for row in range(max(self._n_inputs, self._n_rows)): - for column in range(-1, self._n_columns + 1): - - if column == -1: - if row < self._n_inputs: - s += pretty_node_str(self.input_nodes[row]) - else: - s += empty_node_str() - s += "\t" - - elif column < self._n_columns: - if row < self._n_rows: - s += pretty_node_str(self.hidden_nodes[row + column * self._n_rows]) - else: - s += empty_node_str() - s += "\t" - else: - if row < self._n_outputs: - s += pretty_node_str(self.output_nodes[row]) - else: - s += empty_node_str() - s += "\t" + #for row in range(max(self._n_inputs, self._n_rows)): + for idx in range(self._n_inputs + self._n_columns + self._n_outputs): + if idx < self._n_inputs: + s += pretty_node_str(self.input_nodes[idx]) + + elif idx < self._n_inputs + self._n_columns: + s += pretty_node_str(self.hidden_nodes[idx - self._n_inputs]) + else: + s += pretty_node_str(self.output_nodes[idx - self._n_inputs - self._n_columns]) + s += "\t" s += "\n" return s @@ -116,7 +103,6 @@ def parse_genome(self, genome: "Genome") -> None: self._n_inputs = genome._n_inputs self._n_outputs = genome._n_outputs self._n_columns = genome._n_columns - self._n_rows = genome._n_rows self._parameter_names_to_values = copy.deepcopy(genome._parameter_names_to_values) self._nodes = [] @@ -137,7 +123,7 @@ def parse_genome(self, genome: "Genome") -> None: self._determine_active_nodes() def _hidden_column_idx(self, idx: int) -> int: - return (idx - self._n_inputs) // self._n_rows + return idx - self._n_inputs @property def input_nodes(self) -> List[Node]: From e3070d897a3334edf7b62ac7f1e2c3cdb657d3ee Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:48:17 +0100 Subject: [PATCH 03/12] remove n_rows=1 in node validation --- cgp/node_validation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cgp/node_validation.py b/cgp/node_validation.py index aea9dbc6..4444f6c5 100644 --- a/cgp/node_validation.py +++ b/cgp/node_validation.py @@ -27,7 +27,7 @@ def _create_genome(cls: Type["OperatorNode"]) -> "Genome": from .genome import ID_INPUT_NODE, ID_NON_CODING_GENE, ID_OUTPUT_NODE, Genome primitives = (cls,) - genome = Genome(1, 1, 1, 1, primitives) + genome = Genome(1, 1, 1, primitives) dna = [ID_INPUT_NODE] arity = max(cls._arity, 1) for _ in range(arity): From 35017d04aadd55dfda7d48ab67d2b330217e9153 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:49:09 +0100 Subject: [PATCH 04/12] change genome_params in conftest --- test/conftest.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/conftest.py b/test/conftest.py index 383cbcf1..37421f81 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -32,8 +32,6 @@ def genome_params(): "n_inputs": 2, "n_outputs": 1, "n_columns": 3, - "n_rows": 3, - "levels_back": 2, "primitives": (cgp.Add, cgp.Sub, cgp.ConstantFloat), } From 12212c7b69986ffc5906e6c899e0551e13d596e8 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:50:00 +0100 Subject: [PATCH 05/12] update genome tests --- test/test_genome.py | 180 +++++++++----------------------------------- 1 file changed, 36 insertions(+), 144 deletions(-) diff --git a/test/test_genome.py b/test/test_genome.py index 34ae3b47..648f1666 100644 --- a/test/test_genome.py +++ b/test/test_genome.py @@ -9,11 +9,11 @@ def test_check_dna_consistency(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) genome.dna = [ ID_INPUT_NODE, @@ -169,16 +169,14 @@ def test_check_dna_consistency(): def test_permissible_addresses(rng): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 4, "n_rows": 3, "levels_back": 2} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 4,} primitives = (cgp.Add,) genome = cgp.Genome( params["n_inputs"], params["n_outputs"], params["n_columns"], - params["n_rows"], primitives, - params["levels_back"], ) genome.randomize(rng) @@ -189,28 +187,28 @@ def test_permissible_addresses(rng): expected_for_hidden = [ [0, 1], - [0, 1, 2, 3, 4], - [0, 1, 2, 3, 4, 5, 6, 7], - [0, 1, 5, 6, 7, 8, 9, 10], + [0, 1, 2], + [0, 1, 2, 3], + [0, 1, 2, 3, 4] ] for column_idx in range(params["n_columns"]): - region_idx = params["n_inputs"] + params["n_rows"] * column_idx + region_idx = params["n_inputs"] + column_idx assert expected_for_hidden[column_idx] == genome._permissible_addresses(region_idx) - expected_for_output = list(range(params["n_inputs"] + params["n_rows"] * params["n_columns"])) + expected_for_output = list(range(params["n_inputs"] + params["n_columns"])) for output_idx in range(params["n_outputs"]): - region_idx = params["n_inputs"] + params["n_rows"] * params["n_columns"] + output_idx + region_idx = params["n_inputs"] + params["n_columns"] + output_idx assert expected_for_output == genome._permissible_addresses(region_idx) def test_region_iterators(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) genome.dna = [ ID_INPUT_NODE, @@ -237,47 +235,9 @@ def test_region_iterators(): assert region == [ID_OUTPUT_NODE, 0, ID_NON_CODING_GENE] -def test_check_levels_back_consistency(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 4, "n_rows": 3, "levels_back": None} - - primitives = (cgp.Add,) - - params["levels_back"] = 0 - with pytest.raises(ValueError): - cgp.Genome( - params["n_inputs"], - params["n_outputs"], - params["n_columns"], - params["n_rows"], - primitives, - params["levels_back"], - ) - - params["levels_back"] = params["n_columns"] + 1 - with pytest.raises(ValueError): - cgp.Genome( - params["n_inputs"], - params["n_outputs"], - params["n_columns"], - params["n_rows"], - primitives, - params["levels_back"], - ) - - params["levels_back"] = params["n_columns"] - 1 - cgp.Genome( - params["n_inputs"], - params["n_outputs"], - params["n_columns"], - params["n_rows"], - primitives, - params["levels_back"], - ) - - def test_catch_invalid_allele_in_inactive_region(): primitives = (cgp.ConstantFloat,) - genome = cgp.Genome(1, 1, 1, 1, primitives) + genome = cgp.Genome(1, 1, 1, primitives) # should raise error: ConstantFloat node has no addresses, but silent # address gene should still specify valid address @@ -311,7 +271,7 @@ def objective(ind): def test_is_gene_in_input_region(rng): - genome = cgp.Genome(2, 1, 2, 1, (cgp.Add,)) + genome = cgp.Genome(2, 1, 2, (cgp.Add,)) genome.randomize(rng) assert genome._is_gene_in_input_region(0) @@ -319,7 +279,7 @@ def test_is_gene_in_input_region(rng): def test_is_gene_in_hidden_region(rng): - genome = cgp.Genome(2, 1, 2, 1, (cgp.Add,)) + genome = cgp.Genome(2, 1, 2, (cgp.Add,)) genome.randomize(rng) assert genome._is_gene_in_hidden_region(6) @@ -329,7 +289,7 @@ def test_is_gene_in_hidden_region(rng): def test_is_gene_in_output_region(rng): - genome = cgp.Genome(2, 1, 2, 1, (cgp.Add,)) + genome = cgp.Genome(2, 1, 2, (cgp.Add,)) genome.randomize(rng) assert genome._is_gene_in_output_region(12) @@ -340,20 +300,18 @@ def test_mutation_rate(rng, mutation_rate): n_inputs = 1 n_outputs = 1 n_columns = 4 - n_rows = 3 - genome = cgp.Genome(n_inputs, n_outputs, n_columns, n_rows, (cgp.Add, cgp.Sub)) + genome = cgp.Genome(n_inputs, n_outputs, n_columns, (cgp.Add, cgp.Sub)) genome.randomize(rng) - def count_n_immutable_genes(n_inputs, n_outputs, n_rows): + def count_n_immutable_genes(n_inputs, n_outputs): length_per_region = genome.primitives.max_arity + 1 # function gene + address gene n_immutable_genes = n_inputs * length_per_region # none of the input genes are mutable n_immutable_genes += n_outputs * ( length_per_region - 1 ) # only one gene per output can be mutated if n_inputs == 1: - n_immutable_genes += ( - n_rows * genome.primitives.max_arity - ) # address gene in the first (hidden) column can't be mutated + n_immutable_genes += genome.primitives.max_arity + # address gene in the first (hidden) column can't be mutated # if only one input node exists return n_immutable_genes @@ -364,7 +322,7 @@ def count_mutations(dna0, dna1): n_differences += 1 return n_differences - n_immutable_genes = count_n_immutable_genes(n_inputs, n_outputs, n_rows) + n_immutable_genes = count_n_immutable_genes(n_inputs, n_outputs) n_mutations_mean_expected = mutation_rate * (len(genome.dna) - n_immutable_genes) n_mutations_std_expected = np.sqrt( (len(genome.dna) - n_immutable_genes) * mutation_rate * (1 - mutation_rate) @@ -407,24 +365,6 @@ def test_only_silent_mutations(genome_params, mutation_rate, rng): 0, 0, 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, ID_OUTPUT_NODE, 2, ID_NON_CODING_GENE, @@ -467,16 +407,16 @@ def test_permissible_values(genome_params): n_inputs = 2 n_outputs = 1 n_columns = 3 - n_rows = 3 - levels_back = 2 + # 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) + genome = cgp.Genome(n_inputs, n_outputs, n_columns, primitives) 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_addresses_second_internal_column = np.array([0, 1, 2]) + permissible_addresses_third_internal_column = np.array([0, 1, 2, 3]) + permissible_addresses_output = np.array([0, 1, 2, 3, 4]) permissible_values_expected = [ np.array(ID_INPUT_NODE), @@ -489,27 +429,9 @@ def test_permissible_values(genome_params): 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), @@ -544,7 +466,6 @@ def test_genome_reordering_empirically(rng): "n_inputs": 2, "n_outputs": 1, "n_columns": 14, - "n_rows": 1, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat, cgp.Parameter), } @@ -618,40 +539,10 @@ def test_genome_reordering_empirically(rng): assert sympy_expression_after_reorder == sympy_expression -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_parameters_to_numpy_array(): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 1, 2, 1, primitives) + genome = cgp.Genome(1, 1, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, @@ -684,7 +575,7 @@ def test_parameters_to_numpy_array(): def test_update_parameters_from_numpy_array(): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 1, 2, 1, primitives) + genome = cgp.Genome(1, 1, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, @@ -715,7 +606,7 @@ def test_update_parameters_from_numpy_array(): def test_parameters_numpy_array_consistency(): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 1, 2, 1, primitives) + genome = cgp.Genome(1, 1, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, @@ -753,7 +644,6 @@ def test_ncolumns_zero(rng): "n_inputs": 1, "n_outputs": 1, "n_columns": 0, - "n_rows": 1, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat), } genome = cgp.Genome(**genome_params) @@ -786,13 +676,13 @@ def test_splice_dna(genome_params, rng): 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 + [] = genome.splice_dna(new_dna, hidden_start_node=3) # only 3 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 + address_node = genome.splice_dna(new_dna, hidden_start_node=1) + assert address_node == 3 # 2 + n_inputs dna_insert = [0, 0, 1, 1, 1, 1] address_node = genome.splice_dna(dna_insert) @@ -812,7 +702,7 @@ def test_change_address_gene_of_output_node(genome_params, rng): 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): + for new_address in range(4): genome.change_address_gene_of_output_node(new_address) assert genome.dna[-2] == new_address @@ -832,6 +722,8 @@ def test_change_address_gene_of_output_node(genome_params, rng): def test_set_expression_for_output(genome_params, rng): sympy = pytest.importorskip("sympy") + genome_params["n_columns"] = 4 + genome = cgp.Genome(**genome_params) genome.randomize(rng) @@ -846,6 +738,6 @@ def test_set_expression_for_output(genome_params, rng): genome.set_expression_for_output(new_dna) assert CartesianGraph(genome).to_sympy() == x_0 - x_1 - new_dna = [0, 0, 1, 2, 0, 0, 1, 0, 0, 0, 2, 3] # x_0+x_1; 1.0; 0; x_0+x_1 + 1.0 + new_dna = [0, 0, 1, 2, 0, 0, 0, 2, 3] # x_0+x_1; 1.0; x_0+x_1 + 1.0 genome.set_expression_for_output(new_dna) assert CartesianGraph(genome).to_sympy() == x_0 + x_1 + 1.0 From adf73d6af69cf0e34433eab10460594f32b9d8de Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:54:11 +0100 Subject: [PATCH 06/12] update genome params in tests --- test/test_cartesian_graph.py | 181 ++++----------------------- test/test_ea_mu_plus_lambda.py | 2 - test/test_hl_api.py | 6 +- test/test_local_search.py | 4 +- test/test_ls_evolution_strategies.py | 6 +- test/test_node.py | 39 ++---- test/test_population.py | 3 - test/test_utils.py | 2 - 8 files changed, 40 insertions(+), 203 deletions(-) diff --git a/test/test_cartesian_graph.py b/test/test_cartesian_graph.py index 0d71ab7d..9b1c85b8 100644 --- a/test/test_cartesian_graph.py +++ b/test/test_cartesian_graph.py @@ -9,7 +9,7 @@ def test_to_func_simple(): primitives = (cgp.Add,) - genome = cgp.Genome(2, 1, 1, 1, primitives) + genome = cgp.Genome(2, 1, 1, primitives) genome.dna = [ ID_INPUT_NODE, @@ -34,7 +34,7 @@ def test_to_func_simple(): assert x[0] + x[1] == pytest.approx(y) primitives = (cgp.Sub,) - genome = cgp.Genome(2, 1, 1, 1, primitives) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns=1, primitives=primitives) genome.dna = [ ID_INPUT_NODE, @@ -61,7 +61,7 @@ def test_to_func_simple(): def test_compile_two_columns(): primitives = (cgp.Add, cgp.Sub) - genome = cgp.Genome(2, 1, 2, 1, primitives, 1) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns= 2, primitives=primitives) genome.dna = [ ID_INPUT_NODE, @@ -89,57 +89,15 @@ def test_compile_two_columns(): assert x[0] - (x[0] + x[1]) == pytest.approx(y) -def test_compile_two_columns_two_rows(): - primitives = (cgp.Add, cgp.Sub) - genome = cgp.Genome(2, 2, 2, 2, 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, - 1, - 0, - 0, - 2, - 0, - 2, - 3, - ID_OUTPUT_NODE, - 4, - ID_NON_CODING_GENE, - ID_OUTPUT_NODE, - 5, - 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[0]) - assert (x[0] + x[1]) + (x[0] - x[1]) == pytest.approx(y[1]) - - def test_compile_addsubmul(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 2, "n_rows": 2, "levels_back": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 3,} primitives = (cgp.Add, cgp.Sub, cgp.Mul) genome = cgp.Genome( params["n_inputs"], params["n_outputs"], params["n_columns"], - params["n_rows"], primitives, - params["levels_back"], ) genome.dna = [ ID_INPUT_NODE, @@ -151,15 +109,12 @@ def test_compile_addsubmul(): 2, 0, 1, - 1, + 0, 0, 1, 1, 2, 3, - 0, - 0, - 0, ID_OUTPUT_NODE, 4, ID_NON_CODING_GENE, @@ -170,12 +125,12 @@ def test_compile_addsubmul(): x = [5.0, 2.0] y = f(*x) - assert (x[0] * x[1]) - (x[0] - x[1]) == pytest.approx(y) + assert (x[0] * x[1]) - (x[0] + x[1]) == pytest.approx(y) def test_to_numpy(rng): primitives = (cgp.Add, cgp.Mul, cgp.ConstantFloat) - genome = cgp.Genome(1, 1, 2, 2, primitives, 1) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=3, primitives=primitives) # f(x) = x ** 2 + 1. genome.dna = [ ID_INPUT_NODE, @@ -190,9 +145,6 @@ def test_to_numpy(rng): 0, 1, 2, - 0, - 0, - 1, ID_OUTPUT_NODE, 3, ID_NON_CODING_GENE, @@ -209,7 +161,7 @@ def test_to_numpy(rng): batch_sizes = [1, 10] primitives = (cgp.Mul, cgp.ConstantFloat) -genome = [cgp.Genome(1, 1, 2, 2, primitives, 1) for i in range(2)] +genome = [cgp.Genome(n_inputs=1, n_outputs=1, n_columns=2, primitives=primitives) for i in range(2)] # Function: f(x) = 1*x genome[0].dna = [ ID_INPUT_NODE, @@ -218,17 +170,11 @@ def test_to_numpy(rng): 1, 0, 0, - 1, - 0, - 0, - 0, - 0, - 1, 0, 0, 1, ID_OUTPUT_NODE, - 3, + 2, ID_NON_CODING_GENE, ] # Function: f(x) = 1 @@ -242,18 +188,12 @@ def test_to_numpy(rng): 1, 0, 0, - 0, - 0, - 1, - 0, - 0, - 1, ID_OUTPUT_NODE, 1, ID_NON_CODING_GENE, ] -genome += [cgp.Genome(1, 2, 2, 2, primitives, 1) for i in range(2)] +genome += [cgp.Genome(n_inputs=1, n_outputs=2, n_columns=3, primitives=primitives) for i in range(2)] # Function: f(x) = (1*x, 1*1) genome[2].dna = [ ID_INPUT_NODE, @@ -262,9 +202,6 @@ def test_to_numpy(rng): 1, 0, 0, - 1, - 0, - 0, 0, 0, 1, @@ -272,10 +209,10 @@ def test_to_numpy(rng): 1, 1, ID_OUTPUT_NODE, - 3, + 2, ID_NON_CODING_GENE, ID_OUTPUT_NODE, - 4, + 3, ID_NON_CODING_GENE, ] # Function: f(x) = (1, x*x) @@ -286,9 +223,6 @@ def test_to_numpy(rng): 1, 0, 0, - 1, - 0, - 0, 0, 1, 1, @@ -299,7 +233,7 @@ def test_to_numpy(rng): 1, ID_NON_CODING_GENE, ID_OUTPUT_NODE, - 3, + 2, ID_NON_CODING_GENE, ] @@ -332,7 +266,7 @@ def test_to_sympy(rng): sympy = pytest.importorskip("sympy") primitives = (cgp.Add, cgp.ConstantFloat) - genome = cgp.Genome(1, 1, 2, 2, primitives, 1) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=3, primitives=primitives) # f = x_0 + x_0 + 1.0 genome.dna = [ @@ -348,9 +282,6 @@ def test_to_sympy(rng): 0, 1, 2, - 0, - 0, - 1, ID_OUTPUT_NODE, 3, ID_NON_CODING_GENE, @@ -373,7 +304,7 @@ def test_allow_sympy_expr_with_infinities(): pytest.importorskip("sympy") primitives = (cgp.Sub, cgp.Div) - genome = cgp.Genome(1, 1, 2, 1, primitives, 1) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=2, primitives=primitives) # x[0] / (x[0] - x[0]) genome.dna = [ @@ -401,21 +332,18 @@ def test_allow_powers_of_x_0(): pytest.importorskip("sympy") primitives = (cgp.Sub, cgp.Mul) - genome = cgp.Genome(1, 1, 2, 1, primitives, 1) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=1, primitives=primitives) # 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, + 1, ID_NON_CODING_GENE, ] graph = cgp.CartesianGraph(genome) @@ -424,7 +352,7 @@ def test_allow_powers_of_x_0(): def test_input_dim_python(rng): - genome = cgp.Genome(2, 1, 1, 1, (cgp.ConstantFloat,)) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns=1, primitives=(cgp.ConstantFloat,)) genome.randomize(rng) f = cgp.CartesianGraph(genome).to_func() @@ -442,7 +370,7 @@ def test_input_dim_python(rng): def test_input_dim_numpy(rng): - genome = cgp.Genome(2, 1, 1, 1, (cgp.ConstantFloat,)) + genome = cgp.Genome(2, 1, 1, (cgp.ConstantFloat,)) genome.randomize(rng) f = cgp.CartesianGraph(genome).to_numpy() @@ -465,7 +393,7 @@ def test_input_dim_numpy(rng): def test_input_dim_torch(rng): torch = pytest.importorskip("torch") - genome = cgp.Genome(2, 1, 1, 1, (cgp.ConstantFloat,)) + genome = cgp.Genome(2, 1, 1, (cgp.ConstantFloat,)) genome.randomize(rng) f = cgp.CartesianGraph(genome).to_torch() @@ -487,7 +415,7 @@ def test_input_dim_torch(rng): def test_pretty_str(): primitives = (cgp.Sub, cgp.Mul) - genome = cgp.Genome(1, 1, 2, 1, primitives, 1) + genome = cgp.Genome(1, 1, 2, primitives) # x[0] ** 2 genome.dna = [ @@ -516,73 +444,6 @@ def test_pretty_str(): assert node.__class__.__name__ in pretty_str -def test_pretty_str_with_unequal_inputs_rows_outputs(): - primitives = (cgp.Add,) - - # less rows than inputs/outputs - genome = cgp.Genome(1, 1, 1, 2, primitives) - # f(x) = x[0] + x[0] - genome.dna = [ - ID_INPUT_NODE, - ID_NON_CODING_GENE, - ID_NON_CODING_GENE, - 0, - 0, - 0, - 0, - 0, - 0, - ID_OUTPUT_NODE, - 1, - ID_NON_CODING_GENE, - ] - graph = cgp.CartesianGraph(genome) - - expected_pretty_str = """ -00 * InputNode \t01 * Add (00,00) \t03 * OutputNode (01) \t - \t02 Add \t \t -""" - assert graph.pretty_str() == expected_pretty_str - - # more rows than inputs/outputs - genome = cgp.Genome(3, 3, 1, 2, primitives) - # f(x) = [x[0] + x[1], x[0] + x[1], x[1] + x[2]] - genome.dna = [ - ID_INPUT_NODE, - ID_NON_CODING_GENE, - ID_NON_CODING_GENE, - 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, - 0, - 1, - 2, - ID_OUTPUT_NODE, - 3, - ID_NON_CODING_GENE, - ID_OUTPUT_NODE, - 3, - ID_NON_CODING_GENE, - ID_OUTPUT_NODE, - 4, - ID_NON_CODING_GENE, - ] - graph = cgp.CartesianGraph(genome) - - expected_pretty_str = """ -00 * InputNode \t03 * Add (00,01) \t05 * OutputNode (03) \t -01 * InputNode \t04 * Add (01,02) \t06 * OutputNode (03) \t -02 * InputNode \t \t07 * OutputNode (04) \t -""" - assert graph.pretty_str() == expected_pretty_str - - def test_repr(rng, genome_params): genome = cgp.Genome(**genome_params) genome.randomize(rng) diff --git a/test/test_ea_mu_plus_lambda.py b/test/test_ea_mu_plus_lambda.py index 2bf0868c..d131bdb6 100644 --- a/test/test_ea_mu_plus_lambda.py +++ b/test/test_ea_mu_plus_lambda.py @@ -120,8 +120,6 @@ def objective(ind): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, - "levels_back": None, "primitives": (cgp.Parameter,), } diff --git a/test/test_hl_api.py b/test/test_hl_api.py index 2b6736cf..eddd224a 100644 --- a/test/test_hl_api.py +++ b/test/test_hl_api.py @@ -108,16 +108,12 @@ def f1(x): "n_inputs": 1, "n_outputs": 1, "n_columns": 4, - "n_rows": 2, - "levels_back": 2, "primitives": (cgp.Add, cgp.Mul), }, { "n_inputs": 2, "n_outputs": 1, - "n_columns": 2, - "n_rows": 2, - "levels_back": 2, + "n_columns": 4, "primitives": (cgp.Sub, cgp.Mul), }, ] diff --git a/test/test_local_search.py b/test/test_local_search.py index a7d3b2d5..8721df09 100644 --- a/test/test_local_search.py +++ b/test/test_local_search.py @@ -8,7 +8,7 @@ def test_gradient_based_step_towards_maximum(): torch = pytest.importorskip("torch") primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 1, 1, 1, primitives) + genome = cgp.Genome(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) @@ -38,7 +38,7 @@ def test_gradient_based_step_towards_maximum_multi_genome(): torch = pytest.importorskip("torch") primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 1, 1, 1, primitives) + genome = cgp.Genome(1, 1, 1, primitives) # f(x) = c genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1] genome2 = genome.clone() diff --git a/test/test_ls_evolution_strategies.py b/test/test_ls_evolution_strategies.py index f1d4cd84..ba9b69cb 100644 --- a/test/test_ls_evolution_strategies.py +++ b/test/test_ls_evolution_strategies.py @@ -7,7 +7,7 @@ def test_step_towards_maximum(rng_seed): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 2, 2, 1, primitives) + genome = cgp.Genome(1, 2, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, @@ -58,7 +58,7 @@ def _objective_convergence_to_maximum(ind): def test_convergence_to_maximum(rng_seed): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 2, 2, 1, primitives) + genome = cgp.Genome(1, 2, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, @@ -88,7 +88,7 @@ def test_convergence_to_maximum(rng_seed): def test_step_towards_maximum_multi_genome(rng_seed): primitives = (cgp.Parameter,) - genome = cgp.Genome(1, 2, 2, 1, primitives) + genome = cgp.Genome(1, 2, 2, primitives) # [f0(x), f1(x)] = [c1, c2] genome.dna = [ ID_INPUT_NODE, diff --git a/test/test_node.py b/test/test_node.py index 8c1d20f5..dcfe5e56 100644 --- a/test/test_node.py +++ b/test/test_node.py @@ -70,11 +70,11 @@ def _test_to_sympy(genome, x, y_target): def test_add(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) # f(x) = x[0] + x[1] genome.dna = [ @@ -99,11 +99,11 @@ def test_add(): def test_sub(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Sub,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) # f(x) = x[0] - x[1] genome.dna = [ @@ -128,11 +128,11 @@ def test_sub(): def test_mul(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Mul,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) # f(x) = x[0] * x[1] genome.dna = [ @@ -157,11 +157,11 @@ def test_mul(): def test_div(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Div,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) # f(x) = x[0] / x[1] genome.dna = [ @@ -186,11 +186,11 @@ def test_div(): def test_pow(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Pow,) genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) # f(x) = x[0] ** x[1] genome.dna = [ @@ -215,12 +215,12 @@ def test_pow(): def test_constant_float(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1, "n_rows": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.ConstantFloat,) # f(x) = c genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], params["n_rows"], primitives, + params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, ) genome.dna = [ ID_INPUT_NODE, @@ -244,7 +244,6 @@ def test_parameter(): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (cgp.Parameter,) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -267,7 +266,6 @@ class CustomParameter(cgp.Parameter): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (CustomParameter,) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -285,7 +283,6 @@ def test_parameter_two_nodes(): "n_inputs": 1, "n_outputs": 1, "n_columns": 3, - "n_rows": 1, } primitives = (cgp.Parameter, cgp.Add) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -328,7 +325,6 @@ class CustomParameter(cgp.Parameter): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (CustomParameter,) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -358,7 +354,6 @@ class DoubleParameter(cgp.OperatorNode): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (DoubleParameter,) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -378,7 +373,6 @@ class CustomParameter(cgp.Parameter): "n_inputs": 1, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (CustomParameter, CustomParameter) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -410,7 +404,6 @@ def test_if_else_operator(): "n_inputs": 3, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, } primitives = (cgp.IfElse,) genome = cgp.Genome(**genome_params, primitives=primitives) @@ -461,7 +454,7 @@ class CustomAdd(cgp.OperatorNode): def test_raise_broken_def_numpy_output(): - with pytest.raises(ValueError): + with pytest.raises(TypeError): class CustomAdd(cgp.OperatorNode): _arity = 2 @@ -520,8 +513,6 @@ class MyScaledAdd(cgp.node.OperatorNode): "n_inputs": 2, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, - "levels_back": 1, "primitives": primitives, } @@ -564,8 +555,6 @@ class MyScaledAdd(cgp.node.OperatorNode): "n_inputs": 2, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, - "levels_back": 1, "primitives": primitives, } @@ -610,8 +599,6 @@ class MyScaledAdd(cgp.node.OperatorNode): "n_inputs": 2, "n_outputs": 1, "n_columns": 1, - "n_rows": 1, - "levels_back": 1, "primitives": primitives, } diff --git a/test/test_population.py b/test/test_population.py index 729b5b83..512fdc18 100644 --- a/test/test_population.py +++ b/test/test_population.py @@ -82,8 +82,6 @@ def individual_init(ind): "n_inputs": 1, "n_outputs": 1, "n_columns": 3, - "n_rows": 1, - "levels_back": None, "primitives": (cgp.Add, cgp.Sub, cgp.ConstantFloat), } @@ -113,7 +111,6 @@ def test_ncolumns_zero(population_params): "n_inputs": 1, "n_outputs": 1, "n_columns": 0, - "n_rows": 1, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat), } pop = cgp.Population(**population_params, genome_params=genome_params) diff --git a/test/test_utils.py b/test/test_utils.py index 2b7ae5c8..c8980051 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -158,8 +158,6 @@ def test_fec_cache_decorator_with_multiple_inputs_multiple_outputs(genome_params "n_inputs": 2, "n_outputs": 2, "n_columns": 1, - "n_rows": 1, - "levels_back": None, "primitives": (cgp.Add, cgp.Sub), } From 4197bc560584d1855520276312eefce08d3e55b2 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 18:54:52 +0100 Subject: [PATCH 07/12] update genome params in test_individual --- test/test_individual.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/test/test_individual.py b/test/test_individual.py index b98eebf3..2ac7b806 100644 --- a/test/test_individual.py +++ b/test/test_individual.py @@ -16,8 +16,6 @@ "n_inputs": 1, "n_outputs": 1, "n_columns": 2, - "n_rows": 1, - "levels_back": 2, }, primitives=(cgp.Add, cgp.Parameter), dna=[ @@ -85,7 +83,7 @@ def _unpack_genome(individual, individual_type="SingleGenome"): def test_pickle_individual(individual_type): primitives = (cgp.Add,) - genome = cgp.Genome(1, 1, 1, 1, primitives) + genome = cgp.Genome(1, 1, 1, primitives) individual = _create_individual(genome, individual_type=individual_type) with open("individual.pkl", "wb") as f: @@ -167,7 +165,7 @@ def test_individual_with_parameter_numpy(individual_type, params, graph_input_va def test_to_and_from_torch_plus_backprop(individual_type, rng_torch): torch = pytest.importorskip("torch") primitives = (cgp.Mul, cgp.Parameter) - genome = cgp.Genome(1, 1, 2, 2, primitives, 1) + genome = cgp.Genome(1, 1, 4, primitives) # f(x) = c * x genome.dna = [ ID_INPUT_NODE, @@ -233,7 +231,7 @@ def f_target(x): 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) + genome = cgp.Genome(1, 1, 2, primitives) # f(x) = c * x genome.dna = [ ID_INPUT_NODE, @@ -271,7 +269,7 @@ def test_update_parameters_from_torch_class_does_not_reset_fitness_for_unused_pa ): pytest.importorskip("torch") primitives = (cgp.Mul, cgp.Parameter) - genome = cgp.Genome(1, 1, 2, 1, primitives, 1) + genome = cgp.Genome(1, 1, 2, primitives) # f(x) = x ** 2 genome.dna = [ ID_INPUT_NODE, @@ -304,7 +302,7 @@ def test_update_parameters_from_torch_class_does_not_reset_fitness_for_unused_pa @pytest.mark.parametrize("individual_type", ["SingleGenome", "MultiGenome"]) def test_individual_randomize_genome(individual_type, rng): primitives = (cgp.Add, cgp.Mul) - genome = cgp.Genome(1, 1, 2, 1, primitives, 1) + genome = cgp.Genome(1, 1, 2, primitives) genome.randomize(rng) dna_old = list(genome.dna) From b9f1de2885e2e1eda3bcbf2ccbaadb4cea1a3e30 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 19:04:28 +0100 Subject: [PATCH 08/12] rename columns to hidden_units --- cgp/cartesian_graph.py | 10 ++++----- cgp/genome.py | 39 ++++++++++++++++-------------------- test/test_cartesian_graph.py | 25 +++++++++-------------- test/test_genome.py | 15 +++----------- test/test_individual.py | 2 +- test/test_node.py | 38 ++++++++++++----------------------- 6 files changed, 49 insertions(+), 80 deletions(-) diff --git a/cgp/cartesian_graph.py b/cgp/cartesian_graph.py index bdfc1c00..3afdde5d 100644 --- a/cgp/cartesian_graph.py +++ b/cgp/cartesian_graph.py @@ -52,7 +52,7 @@ def __init__(self, genome: "Genome") -> None: """ self._n_inputs: int self._n_outputs: int - self._n_columns: int + self._n_hidden_units: int self._nodes: List self._parameter_names_to_values: Dict[str, float] @@ -82,15 +82,15 @@ def empty_node_str() -> str: s = "\n" #for row in range(max(self._n_inputs, self._n_rows)): - for idx in range(self._n_inputs + self._n_columns + self._n_outputs): + for idx in range(self._n_inputs + self._n_hidden_units + self._n_outputs): if idx < self._n_inputs: s += pretty_node_str(self.input_nodes[idx]) - elif idx < self._n_inputs + self._n_columns: + elif idx < self._n_inputs + self._n_hidden_units: s += pretty_node_str(self.hidden_nodes[idx - self._n_inputs]) else: - s += pretty_node_str(self.output_nodes[idx - self._n_inputs - self._n_columns]) + s += pretty_node_str(self.output_nodes[idx - self._n_inputs - self._n_hidden_units]) s += "\t" s += "\n" @@ -102,7 +102,7 @@ def parse_genome(self, genome: "Genome") -> None: self._n_inputs = genome._n_inputs self._n_outputs = genome._n_outputs - self._n_columns = genome._n_columns + self._n_hidden_units = genome._n_hidden_units self._parameter_names_to_values = copy.deepcopy(genome._parameter_names_to_values) self._nodes = [] diff --git a/cgp/genome.py b/cgp/genome.py index 9f4161b9..dd3e1f42 100644 --- a/cgp/genome.py +++ b/cgp/genome.py @@ -28,7 +28,7 @@ def __init__( self, n_inputs: int = 1, n_outputs: int = 1, - n_columns: int = 128, + n_hidden_units: int = 128, primitives: Optional[Tuple[Type[Node], ...]] = None, ) -> None: """Init function. @@ -39,8 +39,8 @@ def __init__( Number of inputs of the function represented by the genome. Defaults to 1. n_outputs : int, optional Number of outputs of the function represented by the genome. Defaults to 1. - n_columns : int, optional - Number of columns in the representation of the genome. Defaults to 12. + n_hidden_units : int, optional + Number of hidden units in the representation of the genome. Defaults to 128. primitives : Tuple[Type[Node], ...], optional Tuple of primitives that the genome can refer to. Defaults to (+, -, *, 1.0). @@ -49,9 +49,9 @@ def __init__( raise ValueError("n_inputs must be strictly positive") self._n_inputs = n_inputs - if n_columns < 0: + if n_hidden_units < 0: raise ValueError("n_columns must be non-negative") - self._n_columns = n_columns + self._n_hidden_units = n_hidden_units if n_outputs <= 0: raise ValueError("n_outputs must be strictly positive") @@ -109,7 +109,7 @@ def dna(self, value: List[int]) -> None: @property def _n_hidden(self) -> int: - return self._n_columns + return self._n_hidden_units @property def _n_regions(self) -> int: @@ -553,20 +553,20 @@ def _permissible_addresses(self, region_idx: int) -> List[int]: # add all nodes reachable if self._is_hidden_region(region_idx): - hidden_column_idx = self._hidden_column_idx(region_idx) + hidden_idx = self._hidden_idx(region_idx) lower = self._n_inputs - upper = self._n_inputs + hidden_column_idx + upper = self._n_inputs + hidden_idx else: assert self._is_output_region(region_idx) lower = self._n_inputs - upper = self._n_inputs + self._n_columns + upper = self._n_inputs + self._n_hidden_units permissible_addresses += [j for j in range(lower, upper)] return permissible_addresses def _permissible_addresses_for_output_region(self) -> List[int]: - return self._permissible_addresses(self._n_inputs + self._n_columns) + return self._permissible_addresses(self._n_inputs + self._n_hidden_units) def _validate_dna(self, dna: List[int]) -> None: @@ -608,13 +608,13 @@ def _validate_dna(self, dna: List[int]) -> None: if output_region[2:] != [self._id_unused_gene] * (self._primitives.max_arity - 1): raise ValueError("inactive address genes for output nodes need to be empty") - def _hidden_column_idx(self, region_idx: int) -> int: + def _hidden_idx(self, region_idx: int) -> int: assert self._n_inputs <= region_idx - assert region_idx < self._n_inputs + self._n_columns - hidden_column_idx = (region_idx - self._n_inputs) - assert 0 <= hidden_column_idx - assert hidden_column_idx < self._n_columns - return hidden_column_idx + assert region_idx < self._n_inputs + self._n_hidden_units + hidden_idx = (region_idx - self._n_inputs) + assert 0 <= hidden_idx + assert hidden_idx < self._n_hidden_units + return hidden_idx def iter_input_regions( self, dna: Optional[List[int]] = None @@ -760,12 +760,7 @@ def clone(self) -> "Genome": Genome """ - new = Genome( - self._n_inputs, - self._n_outputs, - self._n_columns, - tuple(self._primitives), - ) + new = Genome(self._n_inputs, self._n_outputs, self._n_hidden_units, tuple(self._primitives)) new.dna = self.dna.copy() # Lamarckian strategy: parameter values are passed on to diff --git a/test/test_cartesian_graph.py b/test/test_cartesian_graph.py index 9b1c85b8..9d1479fe 100644 --- a/test/test_cartesian_graph.py +++ b/test/test_cartesian_graph.py @@ -34,7 +34,7 @@ def test_to_func_simple(): assert x[0] + x[1] == pytest.approx(y) primitives = (cgp.Sub,) - genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns=1, primitives=primitives) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_hidden_units=1, primitives=primitives) genome.dna = [ ID_INPUT_NODE, @@ -61,7 +61,7 @@ def test_to_func_simple(): def test_compile_two_columns(): primitives = (cgp.Add, cgp.Sub) - genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns= 2, primitives=primitives) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_hidden_units=2, primitives=primitives) genome.dna = [ ID_INPUT_NODE, @@ -93,12 +93,7 @@ def test_compile_addsubmul(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 3,} primitives = (cgp.Add, cgp.Sub, cgp.Mul) - genome = cgp.Genome( - params["n_inputs"], - params["n_outputs"], - params["n_columns"], - primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -130,7 +125,7 @@ def test_compile_addsubmul(): def test_to_numpy(rng): primitives = (cgp.Add, cgp.Mul, cgp.ConstantFloat) - genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=3, primitives=primitives) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=3, primitives=primitives) # f(x) = x ** 2 + 1. genome.dna = [ ID_INPUT_NODE, @@ -161,7 +156,7 @@ def test_to_numpy(rng): batch_sizes = [1, 10] primitives = (cgp.Mul, cgp.ConstantFloat) -genome = [cgp.Genome(n_inputs=1, n_outputs=1, n_columns=2, primitives=primitives) for i in range(2)] +genome = [cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=2, primitives=primitives) for i in range(2)] # Function: f(x) = 1*x genome[0].dna = [ ID_INPUT_NODE, @@ -193,7 +188,7 @@ def test_to_numpy(rng): ID_NON_CODING_GENE, ] -genome += [cgp.Genome(n_inputs=1, n_outputs=2, n_columns=3, primitives=primitives) for i in range(2)] +genome += [cgp.Genome(n_inputs=1, n_outputs=2, n_hidden_units=3, primitives=primitives) for i in range(2)] # Function: f(x) = (1*x, 1*1) genome[2].dna = [ ID_INPUT_NODE, @@ -266,7 +261,7 @@ def test_to_sympy(rng): sympy = pytest.importorskip("sympy") primitives = (cgp.Add, cgp.ConstantFloat) - genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=3, primitives=primitives) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=3, primitives=primitives) # f = x_0 + x_0 + 1.0 genome.dna = [ @@ -304,7 +299,7 @@ def test_allow_sympy_expr_with_infinities(): pytest.importorskip("sympy") primitives = (cgp.Sub, cgp.Div) - genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=2, primitives=primitives) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=2, primitives=primitives) # x[0] / (x[0] - x[0]) genome.dna = [ @@ -332,7 +327,7 @@ def test_allow_powers_of_x_0(): pytest.importorskip("sympy") primitives = (cgp.Sub, cgp.Mul) - genome = cgp.Genome(n_inputs=1, n_outputs=1, n_columns=1, primitives=primitives) + genome = cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=1, primitives=primitives) # x[0] ** 2 genome.dna = [ @@ -352,7 +347,7 @@ def test_allow_powers_of_x_0(): def test_input_dim_python(rng): - genome = cgp.Genome(n_inputs=2, n_outputs=1, n_columns=1, primitives=(cgp.ConstantFloat,)) + genome = cgp.Genome(n_inputs=2, n_outputs=1, n_hidden_units=1, primitives=(cgp.ConstantFloat,)) genome.randomize(rng) f = cgp.CartesianGraph(genome).to_func() diff --git a/test/test_genome.py b/test/test_genome.py index 648f1666..99e4036a 100644 --- a/test/test_genome.py +++ b/test/test_genome.py @@ -12,9 +12,7 @@ def test_check_dna_consistency(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -172,12 +170,7 @@ def test_permissible_addresses(rng): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 4,} primitives = (cgp.Add,) - genome = cgp.Genome( - params["n_inputs"], - params["n_outputs"], - params["n_columns"], - primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) genome.randomize(rng) for input_idx in range(params["n_inputs"]): @@ -207,9 +200,7 @@ def test_region_iterators(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, diff --git a/test/test_individual.py b/test/test_individual.py index 2ac7b806..da7f6ddc 100644 --- a/test/test_individual.py +++ b/test/test_individual.py @@ -41,7 +41,7 @@ def _create_genome(genome_params, primitives, dna): - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) genome.dna = dna return genome diff --git a/test/test_node.py b/test/test_node.py index dcfe5e56..1f911a0f 100644 --- a/test/test_node.py +++ b/test/test_node.py @@ -73,9 +73,7 @@ def test_add(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Add,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) # f(x) = x[0] + x[1] genome.dna = [ ID_INPUT_NODE, @@ -102,9 +100,7 @@ def test_sub(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Sub,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) # f(x) = x[0] - x[1] genome.dna = [ ID_INPUT_NODE, @@ -131,9 +127,7 @@ def test_mul(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Mul,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) # f(x) = x[0] * x[1] genome.dna = [ ID_INPUT_NODE, @@ -160,9 +154,7 @@ def test_div(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Div,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) # f(x) = x[0] / x[1] genome.dna = [ ID_INPUT_NODE, @@ -189,9 +181,7 @@ def test_pow(): params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} primitives = (cgp.Pow,) - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) # f(x) = x[0] ** x[1] genome.dna = [ ID_INPUT_NODE, @@ -219,9 +209,7 @@ def test_constant_float(): primitives = (cgp.ConstantFloat,) # f(x) = c - genome = cgp.Genome( - params["n_inputs"], params["n_outputs"], params["n_columns"], primitives, - ) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -246,7 +234,7 @@ def test_parameter(): "n_columns": 1, } primitives = (cgp.Parameter,) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x) = c genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1] @@ -268,7 +256,7 @@ class CustomParameter(cgp.Parameter): "n_columns": 1, } primitives = (CustomParameter,) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x) = c genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1] @@ -285,7 +273,7 @@ def test_parameter_two_nodes(): "n_columns": 3, } primitives = (cgp.Parameter, cgp.Add) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x) = c1 + c2 genome.dna = [ ID_INPUT_NODE, @@ -327,7 +315,7 @@ class CustomParameter(cgp.Parameter): "n_columns": 1, } primitives = (CustomParameter,) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x) = c genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1] f = cgp.CartesianGraph(genome).to_func() @@ -356,7 +344,7 @@ class DoubleParameter(cgp.OperatorNode): "n_columns": 1, } primitives = (DoubleParameter,) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # 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() @@ -375,7 +363,7 @@ class CustomParameter(cgp.Parameter): "n_columns": 1, } primitives = (CustomParameter, CustomParameter) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x) = p genome.dna = [ID_INPUT_NODE, ID_NON_CODING_GENE, 0, 0, ID_OUTPUT_NODE, 1] genome._parameter_names_to_values[""] = 1.0 @@ -406,7 +394,7 @@ def test_if_else_operator(): "n_columns": 1, } primitives = (cgp.IfElse,) - genome = cgp.Genome(**genome_params, primitives=primitives) + genome = cgp.Genome(primitives=primitives, **genome_params) # f(x_0, x_1, x_2) = {x_1 if x_0 >= 0, x_2 otherwise} genome.dna = [ From 3ac24c13f6fd86b840e6ab9cd5880232f17fcafb Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 19:09:05 +0100 Subject: [PATCH 09/12] update examples to new genome params names --- examples/example_caching.py | 4 +--- examples/example_differential_evo_regression.py | 4 +--- examples/example_evo_regression.py | 4 +--- examples/example_evo_regression_numpy.py | 4 +--- examples/example_fec_caching.py | 4 +--- examples/example_hurdles.py | 4 +--- examples/example_local_search_evolution_strategies.py | 4 +--- examples/example_mountain_car.py | 4 +--- examples/example_multi_genome.py | 4 +--- examples/example_parametrized_nodes.py | 4 +--- examples/example_piecewise_target_function.py | 4 +--- examples/example_reorder.py | 4 +--- 12 files changed, 12 insertions(+), 36 deletions(-) diff --git a/examples/example_caching.py b/examples/example_caching.py index a674cc57..3f1ddc05 100644 --- a/examples/example_caching.py +++ b/examples/example_caching.py @@ -79,9 +79,7 @@ def objective(individual): "genome_params": { "n_inputs": 1, "n_outputs": 1, - "n_columns": 10, - "n_rows": 2, - "levels_back": 2, + "n_hidden_units": 10, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), }, "evolve_params": {"max_generations": 200, "termination_fitness": -1e-12}, diff --git a/examples/example_differential_evo_regression.py b/examples/example_differential_evo_regression.py index 45590e73..0d0dd386 100644 --- a/examples/example_differential_evo_regression.py +++ b/examples/example_differential_evo_regression.py @@ -99,9 +99,7 @@ def objective(individual, seed): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 20, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 20, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.Parameter), } diff --git a/examples/example_evo_regression.py b/examples/example_evo_regression.py index 39c99c62..954bd485 100644 --- a/examples/example_evo_regression.py +++ b/examples/example_evo_regression.py @@ -128,9 +128,7 @@ def evolution(f_target): genome_params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 12, - "n_rows": 2, - "levels_back": 5, + "n_hidden_units": 12, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.Div, cgp.ConstantFloat), } diff --git a/examples/example_evo_regression_numpy.py b/examples/example_evo_regression_numpy.py index c02bb9a8..a2c7e182 100644 --- a/examples/example_evo_regression_numpy.py +++ b/examples/example_evo_regression_numpy.py @@ -122,9 +122,7 @@ def evolution(f_target): genome_params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 12, - "n_rows": 2, - "levels_back": 5, + "n_hidden_units": 12, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.Div, cgp.ConstantFloat), } diff --git a/examples/example_fec_caching.py b/examples/example_fec_caching.py index b91232e6..efcca1b3 100644 --- a/examples/example_fec_caching.py +++ b/examples/example_fec_caching.py @@ -94,9 +94,7 @@ def objective(individual): "genome_params": { "n_inputs": 1, "n_outputs": 1, - "n_columns": 10, - "n_rows": 2, - "levels_back": 2, + "n_hidden_units": 10, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), }, "evolve_params": {"max_generations": 200, "termination_fitness": -1e-12}, diff --git a/examples/example_hurdles.py b/examples/example_hurdles.py index 62905447..b45319ad 100644 --- a/examples/example_hurdles.py +++ b/examples/example_hurdles.py @@ -116,9 +116,7 @@ def objective_two(individual): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 12, - "n_rows": 1, - "levels_back": 5, + "n_hidden_units": 12, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), } diff --git a/examples/example_local_search_evolution_strategies.py b/examples/example_local_search_evolution_strategies.py index 5125478e..0d9d04cf 100644 --- a/examples/example_local_search_evolution_strategies.py +++ b/examples/example_local_search_evolution_strategies.py @@ -87,9 +87,7 @@ def objective(individual, seed): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 36, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 36, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.Parameter), } diff --git a/examples/example_mountain_car.py b/examples/example_mountain_car.py index 3916e8ba..7b6c81e4 100644 --- a/examples/example_mountain_car.py +++ b/examples/example_mountain_car.py @@ -152,9 +152,7 @@ def evolve(seed): genome_params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 16, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 16, "primitives": ( cgp.Add, cgp.Sub, diff --git a/examples/example_multi_genome.py b/examples/example_multi_genome.py index ccc2f6a5..69f75af7 100644 --- a/examples/example_multi_genome.py +++ b/examples/example_multi_genome.py @@ -75,9 +75,7 @@ def objective(individual): single_genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 12, - "n_rows": 1, - "levels_back": 5, + "n_hidden_units": 12, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), } genome_params = [single_genome_params, single_genome_params] diff --git a/examples/example_parametrized_nodes.py b/examples/example_parametrized_nodes.py index 602a3465..addb435d 100644 --- a/examples/example_parametrized_nodes.py +++ b/examples/example_parametrized_nodes.py @@ -105,9 +105,7 @@ def objective(individual, seed): genome_params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 5, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 5, "primitives": (ParametrizedAdd, cgp.Add, cgp.Sub, cgp.Mul), } diff --git a/examples/example_piecewise_target_function.py b/examples/example_piecewise_target_function.py index a667985f..e1630774 100644 --- a/examples/example_piecewise_target_function.py +++ b/examples/example_piecewise_target_function.py @@ -82,9 +82,7 @@ def objective(individual, rng): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 20, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 20, "primitives": (cgp.IfElse, cgp.Mul, cgp.Add, cgp.Sub, cgp.ConstantFloat,), } diff --git a/examples/example_reorder.py b/examples/example_reorder.py index 6842d3a6..6ece680b 100644 --- a/examples/example_reorder.py +++ b/examples/example_reorder.py @@ -79,9 +79,7 @@ def objective(individual): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 12, - "n_rows": 1, - "levels_back": None, + "n_hidden_units": 12, "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), } From 15ac30ff9d2c406cdff17ce99c0a63c0ef1e7e8a Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 19:17:30 +0100 Subject: [PATCH 10/12] update test from n_columns to n_hidden_units --- test/conftest.py | 2 +- test/test_ea_mu_plus_lambda.py | 2 +- test/test_genome.py | 32 ++++++++++++------------- test/test_hl_api.py | 4 ++-- test/test_individual.py | 2 +- test/test_node.py | 44 +++++++++++++++++----------------- test/test_population.py | 4 ++-- test/test_utils.py | 2 +- 8 files changed, 46 insertions(+), 46 deletions(-) diff --git a/test/conftest.py b/test/conftest.py index 37421f81..362e701d 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -31,7 +31,7 @@ def genome_params(): return { "n_inputs": 2, "n_outputs": 1, - "n_columns": 3, + "n_hidden_units": 3, "primitives": (cgp.Add, cgp.Sub, cgp.ConstantFloat), } diff --git a/test/test_ea_mu_plus_lambda.py b/test/test_ea_mu_plus_lambda.py index d131bdb6..0bb2afed 100644 --- a/test/test_ea_mu_plus_lambda.py +++ b/test/test_ea_mu_plus_lambda.py @@ -119,7 +119,7 @@ def objective(ind): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, "primitives": (cgp.Parameter,), } diff --git a/test/test_genome.py b/test/test_genome.py index 99e4036a..5528639c 100644 --- a/test/test_genome.py +++ b/test/test_genome.py @@ -9,10 +9,10 @@ def test_check_dna_consistency(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -167,10 +167,10 @@ def test_check_dna_consistency(): def test_permissible_addresses(rng): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 4,} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 4,} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) genome.randomize(rng) for input_idx in range(params["n_inputs"]): @@ -185,22 +185,22 @@ def test_permissible_addresses(rng): [0, 1, 2, 3, 4] ] - for column_idx in range(params["n_columns"]): + for column_idx in range(params["n_hidden_units"]): region_idx = params["n_inputs"] + column_idx assert expected_for_hidden[column_idx] == genome._permissible_addresses(region_idx) - expected_for_output = list(range(params["n_inputs"] + params["n_columns"])) + expected_for_output = list(range(params["n_inputs"] + params["n_hidden_units"])) for output_idx in range(params["n_outputs"]): - region_idx = params["n_inputs"] + params["n_columns"] + output_idx + region_idx = params["n_inputs"] + params["n_hidden_units"] + output_idx assert expected_for_output == genome._permissible_addresses(region_idx) def test_region_iterators(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -290,8 +290,8 @@ def test_is_gene_in_output_region(rng): def test_mutation_rate(rng, mutation_rate): n_inputs = 1 n_outputs = 1 - n_columns = 4 - genome = cgp.Genome(n_inputs, n_outputs, n_columns, (cgp.Add, cgp.Sub)) + n_hidden_units = 4 + genome = cgp.Genome(n_inputs, n_outputs, n_hidden_units, (cgp.Add, cgp.Sub)) genome.randomize(rng) def count_n_immutable_genes(n_inputs, n_outputs): @@ -397,11 +397,11 @@ def select_gene_indices_non_silent(mutation_rate, rng): def test_permissible_values(genome_params): n_inputs = 2 n_outputs = 1 - n_columns = 3 + n_hidden_units = 3 # n_rows = 3 # levels_back = 2 primitives = (cgp.Add, cgp.Sub, cgp.ConstantFloat) - genome = cgp.Genome(n_inputs, n_outputs, n_columns, primitives) + genome = cgp.Genome(n_inputs, n_outputs, n_hidden_units, primitives) permissible_function_gene_values = np.arange(len(genome._primitives._primitives)) permissible_addresses_first_internal_column = np.array([0, 1]) @@ -456,7 +456,7 @@ def test_genome_reordering_empirically(rng): genome_params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 14, + "n_hidden_units": 14, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat, cgp.Parameter), } @@ -634,7 +634,7 @@ def test_ncolumns_zero(rng): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 0, + "n_hidden_units": 0, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat), } genome = cgp.Genome(**genome_params) @@ -713,7 +713,7 @@ def test_change_address_gene_of_output_node(genome_params, rng): def test_set_expression_for_output(genome_params, rng): sympy = pytest.importorskip("sympy") - genome_params["n_columns"] = 4 + genome_params["n_hidden_units"] = 4 genome = cgp.Genome(**genome_params) genome.randomize(rng) diff --git a/test/test_hl_api.py b/test/test_hl_api.py index eddd224a..abc6525f 100644 --- a/test/test_hl_api.py +++ b/test/test_hl_api.py @@ -107,13 +107,13 @@ def f1(x): { "n_inputs": 1, "n_outputs": 1, - "n_columns": 4, + "n_hidden_units": 4, "primitives": (cgp.Add, cgp.Mul), }, { "n_inputs": 2, "n_outputs": 1, - "n_columns": 4, + "n_hidden_units": 4, "primitives": (cgp.Sub, cgp.Mul), }, ] diff --git a/test/test_individual.py b/test/test_individual.py index da7f6ddc..ac285461 100644 --- a/test/test_individual.py +++ b/test/test_individual.py @@ -15,7 +15,7 @@ genome_params={ "n_inputs": 1, "n_outputs": 1, - "n_columns": 2, + "n_hidden_units": 2, }, primitives=(cgp.Add, cgp.Parameter), dna=[ diff --git a/test/test_node.py b/test/test_node.py index 1f911a0f..a707806f 100644 --- a/test/test_node.py +++ b/test/test_node.py @@ -70,10 +70,10 @@ def _test_to_sympy(genome, x, y_target): def test_add(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) # f(x) = x[0] + x[1] genome.dna = [ ID_INPUT_NODE, @@ -97,10 +97,10 @@ def test_add(): def test_sub(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Sub,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) # f(x) = x[0] - x[1] genome.dna = [ ID_INPUT_NODE, @@ -124,10 +124,10 @@ def test_sub(): def test_mul(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Mul,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) # f(x) = x[0] * x[1] genome.dna = [ ID_INPUT_NODE, @@ -151,10 +151,10 @@ def test_mul(): def test_div(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Div,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) # f(x) = x[0] / x[1] genome.dna = [ ID_INPUT_NODE, @@ -178,10 +178,10 @@ def test_div(): def test_pow(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Pow,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) # f(x) = x[0] ** x[1] genome.dna = [ ID_INPUT_NODE, @@ -205,11 +205,11 @@ def test_pow(): def test_constant_float(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 1} + params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.ConstantFloat,) # f(x) = c - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) + genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -231,7 +231,7 @@ def test_parameter(): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (cgp.Parameter,) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -253,7 +253,7 @@ class CustomParameter(cgp.Parameter): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (CustomParameter,) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -270,7 +270,7 @@ def test_parameter_two_nodes(): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 3, + "n_hidden_units": 3, } primitives = (cgp.Parameter, cgp.Add) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -312,7 +312,7 @@ class CustomParameter(cgp.Parameter): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (CustomParameter,) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -341,7 +341,7 @@ class DoubleParameter(cgp.OperatorNode): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (DoubleParameter,) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -360,7 +360,7 @@ class CustomParameter(cgp.Parameter): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (CustomParameter, CustomParameter) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -391,7 +391,7 @@ def test_if_else_operator(): genome_params = { "n_inputs": 3, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, } primitives = (cgp.IfElse,) genome = cgp.Genome(primitives=primitives, **genome_params) @@ -500,7 +500,7 @@ class MyScaledAdd(cgp.node.OperatorNode): params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, "primitives": primitives, } @@ -542,7 +542,7 @@ class MyScaledAdd(cgp.node.OperatorNode): params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, "primitives": primitives, } @@ -586,7 +586,7 @@ class MyScaledAdd(cgp.node.OperatorNode): params = { "n_inputs": 2, "n_outputs": 1, - "n_columns": 1, + "n_hidden_units": 1, "primitives": primitives, } diff --git a/test/test_population.py b/test/test_population.py index 512fdc18..8a2e0bbd 100644 --- a/test/test_population.py +++ b/test/test_population.py @@ -81,7 +81,7 @@ def individual_init(ind): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 3, + "n_hidden_units": 3, "primitives": (cgp.Add, cgp.Sub, cgp.ConstantFloat), } @@ -110,7 +110,7 @@ def test_ncolumns_zero(population_params): genome_params = { "n_inputs": 1, "n_outputs": 1, - "n_columns": 0, + "n_hidden_units": 0, "primitives": (cgp.Mul, cgp.Sub, cgp.Add, cgp.ConstantFloat), } pop = cgp.Population(**population_params, genome_params=genome_params) diff --git a/test/test_utils.py b/test/test_utils.py index c8980051..21180a37 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -157,7 +157,7 @@ def test_fec_cache_decorator_with_multiple_inputs_multiple_outputs(genome_params genome_params = { "n_inputs": 2, "n_outputs": 2, - "n_columns": 1, + "n_hidden_units": 1, "primitives": (cgp.Add, cgp.Sub), } From 9271e21883730a2fcffc45a83c989bdf830ce4b7 Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 22:53:09 +0100 Subject: [PATCH 11/12] Make test assertion for unequal randomized genomes --- test/test_utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_utils.py b/test/test_utils.py index 21180a37..5fcb306a 100644 --- a/test/test_utils.py +++ b/test/test_utils.py @@ -422,14 +422,14 @@ def test_custom_compute_key_for_disk_cache(individual, rng): tempfile.mkstemp()[1], compute_key=cgp.utils.compute_key_from_numpy_evaluation_and_args ) def inner_objective(ind): - return ind.to_func()(1.0, 2.0) + return ind.to_func()(2.0, 2.0) def my_compute_key(ind): return 0 @cgp.utils.disk_cache(tempfile.mkstemp()[1], compute_key=my_compute_key) def inner_objective_custom_compute_key(ind): - return ind.to_func()(1.0, 2.0) + return ind.to_func()(2.0, 2.0) individual0 = individual.clone() individual0.genome.randomize(rng) From b7ca73e272f4130092b6d31aa941e9842e27402e Mon Sep 17 00:00:00 2001 From: Henrik Mettler Date: Wed, 26 Jan 2022 22:57:28 +0100 Subject: [PATCH 12/12] black --- cgp/cartesian_graph.py | 5 +++-- cgp/genome.py | 6 ++++-- examples/example_fec_caching.py | 2 +- examples/example_multi_genome.py | 1 - test/test_cartesian_graph.py | 14 +++++++++++--- test/test_genome.py | 25 +++++++++++++++---------- test/test_hl_api.py | 14 ++------------ test/test_individual.py | 6 +----- test/test_node.py | 24 ++++++++++++++++++------ 9 files changed, 55 insertions(+), 42 deletions(-) diff --git a/cgp/cartesian_graph.py b/cgp/cartesian_graph.py index 3afdde5d..bbbc4064 100644 --- a/cgp/cartesian_graph.py +++ b/cgp/cartesian_graph.py @@ -81,7 +81,6 @@ def empty_node_str() -> str: s = "\n" - #for row in range(max(self._n_inputs, self._n_rows)): for idx in range(self._n_inputs + self._n_hidden_units + self._n_outputs): if idx < self._n_inputs: @@ -90,7 +89,9 @@ def empty_node_str() -> str: elif idx < self._n_inputs + self._n_hidden_units: s += pretty_node_str(self.hidden_nodes[idx - self._n_inputs]) else: - s += pretty_node_str(self.output_nodes[idx - self._n_inputs - self._n_hidden_units]) + s += pretty_node_str( + self.output_nodes[idx - self._n_inputs - self._n_hidden_units] + ) s += "\t" s += "\n" diff --git a/cgp/genome.py b/cgp/genome.py index dd3e1f42..b4a4b77f 100644 --- a/cgp/genome.py +++ b/cgp/genome.py @@ -611,7 +611,7 @@ def _validate_dna(self, dna: List[int]) -> None: def _hidden_idx(self, region_idx: int) -> int: assert self._n_inputs <= region_idx assert region_idx < self._n_inputs + self._n_hidden_units - hidden_idx = (region_idx - self._n_inputs) + hidden_idx = region_idx - self._n_inputs assert 0 <= hidden_idx assert hidden_idx < self._n_hidden_units return hidden_idx @@ -760,7 +760,9 @@ def clone(self) -> "Genome": Genome """ - new = Genome(self._n_inputs, self._n_outputs, self._n_hidden_units, tuple(self._primitives)) + new = Genome( + self._n_inputs, self._n_outputs, self._n_hidden_units, tuple(self._primitives) + ) new.dna = self.dna.copy() # Lamarckian strategy: parameter values are passed on to diff --git a/examples/example_fec_caching.py b/examples/example_fec_caching.py index 31c1b35c..91b3908b 100644 --- a/examples/example_fec_caching.py +++ b/examples/example_fec_caching.py @@ -76,7 +76,7 @@ def objective(individual): return individual - + # Finally, we call the `evolve` method to perform the evolutionary search. diff --git a/examples/example_multi_genome.py b/examples/example_multi_genome.py index 2c876804..cc87e6f5 100644 --- a/examples/example_multi_genome.py +++ b/examples/example_multi_genome.py @@ -73,7 +73,6 @@ def objective(individual): seed = 1234 single_genome_params = { - "primitives": (cgp.Add, cgp.Sub, cgp.Mul, cgp.ConstantFloat), } genome_params = [single_genome_params, single_genome_params] diff --git a/test/test_cartesian_graph.py b/test/test_cartesian_graph.py index 9d1479fe..d1b96f9c 100644 --- a/test/test_cartesian_graph.py +++ b/test/test_cartesian_graph.py @@ -90,7 +90,11 @@ def test_compile_two_columns(): def test_compile_addsubmul(): - params = {"n_inputs": 2, "n_outputs": 1, "n_columns": 3,} + params = { + "n_inputs": 2, + "n_outputs": 1, + "n_columns": 3, + } primitives = (cgp.Add, cgp.Sub, cgp.Mul) genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_columns"], primitives) @@ -156,7 +160,9 @@ def test_to_numpy(rng): batch_sizes = [1, 10] primitives = (cgp.Mul, cgp.ConstantFloat) -genome = [cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=2, primitives=primitives) for i in range(2)] +genome = [ + cgp.Genome(n_inputs=1, n_outputs=1, n_hidden_units=2, primitives=primitives) for i in range(2) +] # Function: f(x) = 1*x genome[0].dna = [ ID_INPUT_NODE, @@ -188,7 +194,9 @@ def test_to_numpy(rng): ID_NON_CODING_GENE, ] -genome += [cgp.Genome(n_inputs=1, n_outputs=2, n_hidden_units=3, primitives=primitives) for i in range(2)] +genome += [ + cgp.Genome(n_inputs=1, n_outputs=2, n_hidden_units=3, primitives=primitives) for i in range(2) +] # Function: f(x) = (1*x, 1*1) genome[2].dna = [ ID_INPUT_NODE, diff --git a/test/test_genome.py b/test/test_genome.py index 5528639c..abe57b7d 100644 --- a/test/test_genome.py +++ b/test/test_genome.py @@ -12,7 +12,9 @@ def test_check_dna_consistency(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, @@ -167,10 +169,16 @@ def test_check_dna_consistency(): def test_permissible_addresses(rng): - params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 4,} + params = { + "n_inputs": 2, + "n_outputs": 1, + "n_hidden_units": 4, + } primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) genome.randomize(rng) for input_idx in range(params["n_inputs"]): @@ -178,12 +186,7 @@ def test_permissible_addresses(rng): with pytest.raises(AssertionError): genome._permissible_addresses(region_idx) - expected_for_hidden = [ - [0, 1], - [0, 1, 2], - [0, 1, 2, 3], - [0, 1, 2, 3, 4] - ] + expected_for_hidden = [[0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]] for column_idx in range(params["n_hidden_units"]): region_idx = params["n_inputs"] + column_idx @@ -200,7 +203,9 @@ def test_region_iterators(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE, diff --git a/test/test_hl_api.py b/test/test_hl_api.py index abc6525f..e78963a9 100644 --- a/test/test_hl_api.py +++ b/test/test_hl_api.py @@ -104,18 +104,8 @@ def f1(x): # contains parameters for two distinct CartesianGraphs as list of # two dicts genome_params = [ - { - "n_inputs": 1, - "n_outputs": 1, - "n_hidden_units": 4, - "primitives": (cgp.Add, cgp.Mul), - }, - { - "n_inputs": 2, - "n_outputs": 1, - "n_hidden_units": 4, - "primitives": (cgp.Sub, cgp.Mul), - }, + {"n_inputs": 1, "n_outputs": 1, "n_hidden_units": 4, "primitives": (cgp.Add, cgp.Mul),}, + {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 4, "primitives": (cgp.Sub, cgp.Mul),}, ] evolve_params = {"max_generations": 2000, "termination_fitness": -1e-12} diff --git a/test/test_individual.py b/test/test_individual.py index ac285461..675985cf 100644 --- a/test/test_individual.py +++ b/test/test_individual.py @@ -12,11 +12,7 @@ Params = namedtuple("Params", ["genome_params", "primitives", "dna", "target_function"]) params_list = [ Params( - genome_params={ - "n_inputs": 1, - "n_outputs": 1, - "n_hidden_units": 2, - }, + genome_params={"n_inputs": 1, "n_outputs": 1, "n_hidden_units": 2,}, primitives=(cgp.Add, cgp.Parameter), dna=[ ID_INPUT_NODE, diff --git a/test/test_node.py b/test/test_node.py index a707806f..b35a1ee0 100644 --- a/test/test_node.py +++ b/test/test_node.py @@ -73,7 +73,9 @@ def test_add(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Add,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) # f(x) = x[0] + x[1] genome.dna = [ ID_INPUT_NODE, @@ -100,7 +102,9 @@ def test_sub(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Sub,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) # f(x) = x[0] - x[1] genome.dna = [ ID_INPUT_NODE, @@ -127,7 +131,9 @@ def test_mul(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Mul,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) # f(x) = x[0] * x[1] genome.dna = [ ID_INPUT_NODE, @@ -154,7 +160,9 @@ def test_div(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Div,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) # f(x) = x[0] / x[1] genome.dna = [ ID_INPUT_NODE, @@ -181,7 +189,9 @@ def test_pow(): params = {"n_inputs": 2, "n_outputs": 1, "n_hidden_units": 1} primitives = (cgp.Pow,) - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) # f(x) = x[0] ** x[1] genome.dna = [ ID_INPUT_NODE, @@ -209,7 +219,9 @@ def test_constant_float(): primitives = (cgp.ConstantFloat,) # f(x) = c - genome = cgp.Genome(params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives) + genome = cgp.Genome( + params["n_inputs"], params["n_outputs"], params["n_hidden_units"], primitives + ) genome.dna = [ ID_INPUT_NODE, ID_NON_CODING_GENE,