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)
