def test_unregister(self, instr_set): i_set = InstructionSet() i_set.register(instr_set["int_add"]) i_set.register(instr_set["int_sub"]) i_set.unregister("int_add") assert len(i_set) == 1 assert list(i_set.values())[0].name == "int_sub"
def test_register_by_name(self): i_set = InstructionSet() i_set.register_by_name(".*_mult") print(i_set) assert len(i_set) == 2 assert set([i.name for i in i_set.values()]) == {"int_mult", "float_mult"}
def __init__(self, n_inputs: int, instruction_set: Union[InstructionSet, str], literals: Sequence[Any], erc_generators: Sequence[Callable], distribution: DiscreteProbDistrib = "proportional"): self.n_inputs = n_inputs self.erc_generators = erc_generators self.instruction_set = instruction_set if self.instruction_set == "core": self.instruction_set = InstructionSet(register_core=True) self.type_library = self.instruction_set.type_library self.literals = [ lit if isinstance(lit, Literal) else infer_literal( lit, self.type_library) for lit in literals ] if distribution == "proportional": self.distribution = (DiscreteProbDistrib().add( GeneTypes.INPUT, self.n_inputs).add( GeneTypes.INSTRUCTION, len(self.instruction_set)).add( GeneTypes.CLOSE, sum([ i.code_blocks for i in self.instruction_set.values() ])).add(GeneTypes.LITERAL, len(literals)).add(GeneTypes.ERC, len(erc_generators))) else: self.distribution = distribution
def run_ga_on_odd_test(parallelism): X = np.arange(-10, 10).reshape(-1, 1) y = [[bool(x[0] % 2)] for x in X] instruction_set = (InstructionSet().register_core_by_stack( {"int"}, exclude_stacks={"str", "exec", "code"})) spawner = GeneSpawner(n_inputs=1, instruction_set=instruction_set, literals=[], erc_generators=[ partial(random.randint, 0, 10), ]) est = PushEstimator(spawner=spawner, population_size=30, max_generations=3, simplification_steps=10, parallelism=parallelism) est.fit(X, y) assert isinstance(est.solution, Individual) assert len(est.solution.program.code) > 0 path = "tmp.push" solution = est.solution.copy(deep=True) est.save(path) est.load(path) assert solution == est.solution os.remove(path)
def simple_test_spawner(): instruction_set = InstructionSet().register_core_by_stack({"int"}, exclude_stacks={"str", "exec", "code"}) spawner = GeneSpawner( n_inputs=1, instruction_set=instruction_set, literals=[], erc_generators=[ partial(random.randint, 0, 10), ] ) return spawner
def __init__(self, instruction_set: Union[InstructionSet, str] = "core", reset_on_run: bool = True): self.reset_on_run = reset_on_run # If no instruction set given, create one and register all instructions. if instruction_set == "core": self.instruction_set = InstructionSet(register_core=True) else: self.instruction_set = instruction_set self.type_library = self.instruction_set.type_library # Initialize the PushState and status self.state: PushState = None self.status: PushInterpreterStatus = None self._validate()
def __init__(self, instruction_set: Union[InstructionSet, str] = "core", config: PushInterpreterConfig = None): # If no instruction set given, create one and register all instructions. if instruction_set == "core": self.instruction_set = InstructionSet(register_all=True) else: self.instruction_set = instruction_set self._supported_types = self.instruction_set.supported_types() if config is None: self.config = PushInterpreterConfig() else: self.config = config # Initialize the PushState and status self.reset()
def test_register_core_by_stack_with_exclude(self, core_type_lib): foo = common.instructions(core_type_lib) print([i for i in foo if i.name == "exec_dup_times"][0].required_stacks()) i_set = InstructionSet(register_core=False) i_set.register_core_by_stack({"int"}, exclude_stacks={"str", "exec", "code"}) for i in i_set.values(): if len(i.required_stacks()) > 0: print(i.name, i.required_stacks()) assert i.name not in { "exec_pop", "exec_dup", "exec_dup_times", "exec_swap", "exec_rot", "exec_flush", "exec_stack_depth", "exec_yank", "exec_yank_dup", "exec_shove", "exec_shove_dup" } assert "int" in i.required_stacks() assert "exec" not in i.required_stacks()
def test_ga_on_odd(): X = np.arange(-10, 10).reshape(-1, 1) y = [[bool(x[0] % 2)] for x in X] instruction_set = (InstructionSet().register_by_type( ["int"], exclude=["str", "exec", "code"]).register_n_inputs(X.shape[1])) spawner = GeneSpawner(instruction_set=instruction_set, literals=[], erc_generators=[ lambda: random.randint(0, 10), ]) est = PushEstimator(spawner=spawner, population_size=20, max_generations=10, simplification_steps=100) est.fit(X, y) assert isinstance(est._result.program, CodeBlock) assert len(est._result.program) > 0
["^_^ " * 5], ] y_train_edge = [target_function(x[0]) for x in X_train_edge] X_train_synthetic = [[synthetic_input()] for _ in range(70)] y_train_synthetic = [target_function(x[0]) for x in X_train_synthetic] X_train = X_train_edge + X_train_synthetic y_train = y_train_edge + y_train_synthetic X_test = [[synthetic_input()] for _ in range(100)] y_test = [target_function(x[0]) for x in X_test] # Spawner instruction_set = (InstructionSet().register_by_type( ["int", "bool", "string", "char", "exec", "stdout"]).register_n_inputs(1)) spawner = GeneSpawner( instruction_set=instruction_set, literals=[Char(" "), Char("\n")], erc_generators=[lambda: Char(choice(_possible_chars)), synthetic_input], ) # Estimator est = PushEstimator(search="GA", population_size=1000, max_generations=100, spawner=spawner, last_str_from_stdout=True, verbose=2)
from pyshgp.push.atoms import CodeBlock from pyshgp.push.interpreter import PushInterpreter from pyshgp.push.instruction_set import InstructionSet from pyshgp.gp.genome import Genome # Not using fixture in order to spot unintentional updates during execution. i_set = InstructionSet(register_all=True).register_n_inputs(10) def load_genome(name: str) -> Genome: with open("tests/resources/genomes/" + name + ".json") as f: return Genome.from_json_str(f.read(), i_set) def load_program(name: str) -> CodeBlock: with open("tests/resources/programs/" + name + ".json") as f: return CodeBlock.from_json_str(f.read(), i_set) def test_genome_relu_1(interpreter: PushInterpreter): name = "relu_via_max" genome = load_genome(name) prog = load_program(name) assert genome.to_code_block() == prog def test_genome_relu_2(interpreter: PushInterpreter): name = "relu_via_if" genome = load_genome(name) prog = load_program(name)
def test_register_core(self, all_core_instructions): i_set = InstructionSet().register_core() assert set(i_set.values()) == all_core_instructions
def target_function(s): return s[:-2] + s[:-2] X = np.array([ "abcde", "", "E", "Hi", "Tom", "leprechaun", "zoomzoomzoom", "qwertyuiopasd", "GallopTrotCanter", "Quinona", "_abc" ]).reshape(-1, 1) y = np.array([[target_function(s[0])] for s in X]) instruction_set = ( InstructionSet() .register_by_type(["str", "int"]) .register_n_inputs(X.shape[1]) ) spawner = GeneSpawner( instruction_set=instruction_set, literals=[], erc_generators=[ lambda: random.randint(0, 10), ] ) est = PushEstimator( search="SA",
from pyshgp.gp.estimators import PushEstimator from pyshgp.gp.genome import GeneSpawner from pyshgp.gp.selection import Lexicase from pyshgp.push.instruction_set import InstructionSet def target_function(x: float) -> (float, float): """Generate a training data point.""" return max(0.0, x), max(0.1 * x, x) X = np.arange(-1.0, 1.0, 0.05).reshape([-1, 1]) y = np.array([target_function(x[0]) for x in X]) spawner = GeneSpawner(n_inputs=1, instruction_set=InstructionSet().register_core_by_stack( {"float", "bool"}), literals=[0.1, 0.0], erc_generators=[ lambda: random.randint(0, 10), ]) ep_lex_sel = Lexicase(epsilon=True) if __name__ == "__main__": est = PushEstimator(population_size=300, max_generations=50, simplification_steps=500, spawner=spawner, selector=ep_lex_sel, verbose=2)
def test_register_core_by_stack(self): i_set = InstructionSet() i_set.register_core_by_stack({"int"}) for i in i_set.values(): if len(i.required_stacks()) > 0: assert "int" in i.required_stacks()
X_train_synthetic = [mirror_vectors() for _ in range(10)] + \ [equal_vectors() for _ in range(10)] + \ [random_vectors() for _ in range(10)] X_train = X_train_edge + X_train_synthetic y_train = [[target_function(x[0], x[1])] for x in X_train] X_test = [mirror_vectors() for _ in range(100)] + \ [equal_vectors() for _ in range(100)] + \ [random_vectors() for _ in range(100)] y_test = [[target_function(x[0], x[1])] for x in X_test] spawner = GeneSpawner( n_inputs=2, instruction_set=InstructionSet().register_core_by_stack( {"int", "bool", "vector_int", "exec"}), literals=[" ", "\n"], erc_generators=[ lambda: random.random() < 0.5, ], ) if __name__ == "__main__": est = PushEstimator(search="GA", population_size=500, max_generations=150, spawner=spawner, simplification_steps=100, verbose=2) start = time.time()
def target_function(s): """Generate a training data point.""" return s[:-2] + s[:-2] X = np.array([ "abcde", "", "E", "Hi", "Tom", "leprechaun", "zoomzoomzoom", "qwertyuiopasd", "GallopTrotCanter", "Quinona", "_abc" ]).reshape(-1, 1) y = np.array([[target_function(s[0])] for s in X]) spawner = GeneSpawner( n_inputs=1, instruction_set=InstructionSet().register_core_by_stack({"str", "int"}), literals=[], erc_generators=[ lambda: random.randint(0, 10), ] ) if __name__ == "__main__": est = PushEstimator( spawner=spawner, population_size=300, max_generations=30, initial_genome_size=(10, 50), simplification_steps=500, parallelism=False, verbose=1
import sys from pyshgp.gp.estimators import PushEstimator from pyshgp.gp.genome import GeneSpawner from pyshgp.gp.selection import Lexicase from pyshgp.push.instruction_set import InstructionSet def target_function(x: float) -> (float, float): return (max(0.0, x), max(0.1 * x, x)) X = np.arange(-1.0, 1.0, 0.15).reshape([-1, 1]) y = np.array([target_function(x[0]) for x in X]) instruction_set = (InstructionSet().register_by_type( ["float", "bool"]).register_n_inputs(X.shape[1])) spawner = GeneSpawner(instruction_set=instruction_set, literals=[0.1, 0.0], erc_generators=[ lambda: random.randint(0, 10), ]) ep_lex_sel = Lexicase(epsilon=True) est = PushEstimator(population_size=500, max_generations=50, spawner=spawner, selector=ep_lex_sel, verbose=2)
def check_unary_fn_translation(program_name: str): interpreter = PushInterpreter(InstructionSet(register_core=True)) check_translation(program_name, interpreter)
def simple_gene_spawner(instr_set): i_set = InstructionSet() i_set.register_list([instr_set["int_add"], instr_set["int_sub"], instr_set["exec_if"]]) l_set = [5, 1.2, True] return GeneSpawner(1, i_set, l_set, [random.random])
def instr_set(): return InstructionSet(register_core=True)
def point_instr_set(point_type_library, point_instructions): return ( InstructionSet(type_library=point_type_library, register_core=True) .register_list(point_instructions) )
return Rectangle(float(value[0]), float(value[1])) type_library = (PushTypeLibrary( register_core=False).register(PushFloat).register(RectangleType())) """ Next we define out instruction set using the type library and the two instructions we created. Our two custom instructions as well as the input instructions are defined. The instruction set will register all core instructions that can be supported using only exec, code, float, and rectangle types because the only core PushType we registered was "PushInt" For example, the instruction int_from_float will NOT be registered because our type library does not define a type that would support the "int" stack. """ instruction_set = (InstructionSet( type_library=type_library, register_core=True).register(rectangle_areas_instruction).register( rectangle_from_floats_instruction)) print("Stacks: ", instruction_set.required_stacks()) print("Types: ", type_library.supported_stacks()) print("Instruction Set: ", instruction_set.keys()) print() """ Next we have to declare our "GeneSpawner." We pass to it our instruction_set. n_inputs=2 because we would like the genome to possibly include 2 input instructions. literals=[2.0] because it will detect that 2.0 is a float, and the spawner will pull floats when spawning genes and genomes. """
"""The goal of the Odd problem is to evolve a program that will produce a True if the input integer is odd, and a False if its even. """ import logging import numpy as np import random import sys from pyshgp.gp.estimators import PushEstimator from pyshgp.gp.genome import GeneSpawner from pyshgp.push.instruction_set import InstructionSet X = np.arange(-10, 10).reshape(-1, 1) y = [[bool(x % 2)] for x in X] instruction_set = (InstructionSet(register_all=True).register_n_inputs( X.shape[1])) spawner = GeneSpawner(instruction_set=instruction_set, literals=[], erc_generators=[lambda: random.randint(0, 10)]) est = PushEstimator(spawner=spawner, population_size=500, max_generations=200, verbose=2) if __name__ == "__main__": logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", stream=sys.stdout) est.fit(X, y)
y_train = y_train_edge + y_train_synthetic X_test = [[synthetic_input()] for _ in range(100)] y_test = [target_function(x[0]) for x in X_test] # Spawner def random_char(): """Return a random character.""" return Char(choice(_possible_chars)) spawner = GeneSpawner( n_inputs=1, instruction_set=InstructionSet().register_core_by_stack( {"int", "bool", "string", "char", "exec", "stdout"}), literals=[" ", "\n"], erc_generators=[ random_char, ], ) if __name__ == "__main__": est = PushEstimator(search="GA", population_size=500, max_generations=150, spawner=spawner, simplification_steps=100, last_str_from_stdout=True, parallelism=True, verbose=2)
def test_register(self, instr_set): i_set = InstructionSet() i_set.register(instr_set["int_add"]) assert len(i_set) == 1
PushTypeLibrary(register_core=False) .register(PushFloat) .create_and_register("point", (Point, ), coercion_func=to_point) ) # An instruction set which will register all core instructions that can be supported # using only exec, code, stdout, float, and point types. # # For example, the instruction int_from_float will NOT be registered because # our type library does not define a type that would support the "int" stack. # # Our two custom instructions as well as the input instructions are also defined. instruction_set = ( InstructionSet(type_library=type_library, register_core=True) .register(point_distance_insrt) .register(point_from_floats_instr) ) print(instruction_set.keys()) spawner = GeneSpawner( n_inputs=2, instruction_set=instruction_set, literals=[2.0], erc_generators=[] ) # Our estimator with a custom interpreter defined. est = PushEstimator(
def test_register_list(self, instr_set): i_set = InstructionSet() i_set.register_list([instr_set["int_add"], instr_set["int_sub"]]) assert len(i_set) == 2
import sys from pyshgp.gp.selection import Lexicase from pyshgp.gp.estimators import PushEstimator from pyshgp.gp.genome import GeneSpawner from pyshgp.push.instruction_set import InstructionSet def target_function(a, b): return (2 * a * b) + (b * b) X = np.arange(50).reshape(-1, 2) y = np.array([[target_function(x[0], x[1])] for x in X]) instruction_set = (InstructionSet().register_by_type( ["int"], exclude=["str", "exec", "code"]).register_n_inputs(X.shape[1])) spawner = GeneSpawner(instruction_set=instruction_set, literals=[], erc_generators=[ lambda: random.randint(0, 10), ]) ep_lex_sel = Lexicase(epsilon=True) est = PushEstimator(population_size=200, max_generations=50, spawner=spawner, selector=ep_lex_sel, verbose=2)
from pyshgp.gp.selection import Lexicase from pyshgp.gp.estimators import PushEstimator from pyshgp.gp.genome import GeneSpawner from pyshgp.push.instruction_set import InstructionSet def target_function(a, b): """Generate a training data point.""" return (2 * a * b) + (b * b) X = np.arange(50).reshape(-1, 2) y = np.array([[target_function(x[0], x[1])] for x in X]) instruction_set = (InstructionSet().register_core_by_stack( {"int"}, exclude_stacks={"str", "exec", "code"})) spawner = GeneSpawner(n_inputs=2, instruction_set=instruction_set, literals=[], erc_generators=[ lambda: random.randint(0, 10), ]) ep_lex_sel = Lexicase(epsilon=True) if __name__ == '__main__': est = PushEstimator(population_size=300, max_generations=50, simplification_steps=500, spawner=spawner,