def fit(self, X, y): """Run the search algorithm to synthesize a push program. Parameters ---------- X : pandas dataframe of shape = [n_samples, n_features] The training input samples. y : list, array-like, or pandas dataframe. The target values (class labels in classification, real numbers in regression). Shape = [n_samples] or [n_samples, n_outputs] """ # arity is the number of inputs that the program takes. X, y, arity, y_types = check_X_y(X, y) output_types = [ self.interpreter.type_library.push_type_for_type(t).name for t in y_types ] if self.last_str_from_stdout: ndx = list_rindex(output_types, "str") if ndx is not None: output_types[ndx] = "stdout" self.signature = ProgramSignature(arity=arity, output_stacks=output_types, push_config=self.push_config) self.evaluator = DatasetEvaluator(X, y, interpreter=self.interpreter) self._build_search_algo() self.solution = self.search.run() self.search.config.tear_down()
def test_program_relu_2(push_config: PushConfig, instr_set: InstructionSet): name = "relu_via_if" sig = ProgramSignature(arity=1, output_stacks=["float"], push_config=push_config) check_program(name, [-5], [0.0], sig, instr_set) check_program(name, [5.6], [5.6], sig, instr_set)
def test_relu_1(self, push_config: PushConfig, interpreter: PushInterpreter): name = "relu_via_max" sig = ProgramSignature(arity=1, output_stacks=["float"], push_config=push_config) prog = get_program(name, sig, interpreter) assert prog.pretty_str() == "(input_0 float_from_int 0.0 float_max)"
def test_infinite_growth(self, push_config: PushConfig, interpreter: PushInterpreter): name = "infinite_growth" sig = ProgramSignature(arity=1, output_stacks=["float"], push_config=push_config) prog = get_program(name, sig, interpreter) assert prog.pretty_str() == "(10 exec_dup (int_dup int_mult exec_dup))"
def simple_individuals(atoms, push_config): sig = ProgramSignature(arity=0, output_stacks=["int"], push_config=push_config) return [ Individual(Genome([]), sig), Individual(Genome([atoms["5"]]), sig), Individual(Genome([atoms["5"], atoms["close"]]), sig), Individual(Genome([atoms["5"]]), sig), ]
def test_replace_space_with_newline(self, push_config: PushConfig, interpreter: PushInterpreter): name = "replace_space_with_newline" sig = ProgramSignature(arity=1, output_stacks=["float"], push_config=push_config) prog = get_program(name, sig, interpreter) assert prog.pretty_str( ) == "(input_0 \"\n\" \" \" str_replace_all_char print_str input_0 input_0 \" \" str_remove_all_char str_length)"
def test_fibonacci(self, push_config: PushConfig, interpreter: PushInterpreter): name = "fibonacci" sig = ProgramSignature(arity=1, output_stacks=["float"], push_config=push_config) prog = get_program(name, sig, interpreter) assert prog.pretty_str( ) == "(input_0 0 int_lte exec_when (exec_flush) 1 input_0 2 int_min int_dup_times input_0 2 int_lte exec_when (exec_flush) input_0 2 int_sub exec_do_times (int_dup 2 int_yank_dup int_add))"
def test_program_point_dist(push_config: PushConfig, point_instr_set: InstructionSet): name = "point_distance" sig = ProgramSignature(arity=4, output_stacks=["float"], push_config=push_config) check_program(name, [1.0, 3.0, 3.0, 3.0], [2.0], sig, point_instr_set) check_program(name, [3.0, 2.5, 3.0, -3.0], [5.5], sig, point_instr_set) check_program(name, [0.0, 0.0, 0.0, 0.0], [0], sig, point_instr_set)
def test_program_fibonacci(push_config: PushConfig, instr_set: InstructionSet): name = "fibonacci" sig = ProgramSignature(arity=1, output_stacks=[], push_config=push_config) result1 = check_program(name, [5], [], sig, instr_set) assert list(result1["int"]) == [1, 1, 2, 3, 5] result2 = check_program(name, [1], [], sig, instr_set) assert list(result2["int"]) == [1] result3 = check_program(name, [-2], [], sig, instr_set) assert list(result3["int"]) == []
def test_interpreter_constraints(push_config: PushConfig, instr_set: InstructionSet): name = "infinite_growth" sig = ProgramSignature(arity=0, output_stacks=["int"], push_config=push_config) interpreter = PushInterpreter(instr_set) cb = load_code(name, interpreter) program = Program(code=cb, signature=sig) output = interpreter.run(program, [0], print_trace=True) assert output[0] == int(push_config.numeric_magnitude_limit) assert interpreter.status == PushInterpreterStatus.step_limit_exceeded
def test_program_rswn(push_config: PushConfig, instr_set: InstructionSet): name = "replace_space_with_newline" sig = ProgramSignature(arity=1, output_stacks=["int", "stdout"], push_config=push_config) result1 = check_program(name, ["hello world"], [10, "hello\nworld"], sig, instr_set) assert result1.stdout == "hello\nworld" result2 = check_program(name, ["nospace"], [7, "nospace"], sig, instr_set) assert result2.stdout == "nospace" result3 = check_program(name, [" "], [0, "\n\n\n"], sig, instr_set) assert result3.stdout == "\n\n\n"
def test_point_distance(self, push_config: PushConfig, point_instr_set: InstructionSet): name = "point_distance" sig = ProgramSignature(arity=4, output_stacks=["float"], push_config=push_config) interpreter = PushInterpreter(point_instr_set) prog = get_program(name, sig, interpreter) assert prog.pretty_str( ) == "(input_0 input_1 point_from_floats input_2 input_3 point_from_floats point_dist)"
def population(atoms, push_config): gn = Genome() sig = ProgramSignature(arity=0, output_stacks=[], push_config=push_config) i1 = Individual(gn, sig) i1.error_vector = np.array([0, 20, 0]) # 20 i2 = Individual(gn, sig) i2.error_vector = np.array([3, 3, 3]) # 9 i3 = Individual(gn, sig) i3.error_vector = np.array([1, 2, 3]) # 6 i4 = Individual(gn, sig) i4.error_vector = np.array([4, 3, 5]) # 12 return Population([i1, i2, i3, i4])
def simple_program_signature(push_config): return ProgramSignature(arity=1, output_stacks=["int"], push_config=push_config)