def check_program(name: str, inputs: list, outputs: list,
sig: ProgramSignature, iset: InstructionSet) -> PushState:
"""Returns the PushState for further validation."""
interpreter = PushInterpreter(iset)
prog = get_program(name, sig, interpreter)
assert interpreter.run(prog, inputs) == outputs
return interpreter.state
def error_function(program):
errors = []
for case in cases:
interpreter = PushInterpreter()
outputs = interpreter.run(program, case, ['_boolean', '_boolean', '_boolean'])
targets = two_bit_control_shift(case)
e = 0
if outputs[0] is None:
e += 1e4
elif outputs[0] != targets[0]:
e += 1
if outputs[1] is None:
e += 1e4
elif outputs[1] != targets[1]:
e += 1
if outputs[2] is None:
e += 1e4
elif outputs[2] != targets[2]:
e += 1
errors.append(e)
return errors
def __init__(self,
interpreter: PushInterpreter = "default",
penalty: float = 1e6):
self.penalty = penalty
if interpreter == "default":
self.interpreter = PushInterpreter()
else:
self.interpreter = interpreter
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 error_function(program, debug=False):
errors = []
for case in training_set:
interpreter = PushInterpreter()
result = interpreter.run(program, [case[0]], ['_integer'], debug)[0]
if result is None:
errors.append(1e5)
else:
errors.append((case[1] - result)**2)
return errors
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 error_function(program, debug=False):
errors = []
for case in training_set:
interpreter = PushInterpreter()
interpreter.run(program, case[0], [], debug)
result = interpreter.state.stdout
if result is None:
errors.append(1e5)
else:
errors.append(int(result != case[1]))
return errors
def error_function(program):
errors = []
for case in cases:
interpreter = PushInterpreter()
output = interpreter.run(program, [case], ['_vector_boolean'])[0]
if output is None:
errors.append(1e5)
else:
target = binary_decrement(case)
errors.append(levenshtein_distance(output, target))
return errors
def error_function(program, debug=False):
errors = []
for case in training_set:
interpreter = PushInterpreter()
result = interpreter.run(program, [case[0]], ['_vector_integer'],
debug)[0]
if result is None:
errors.append(1e5)
else:
errors.append(levenshtein_distance(case[1], result))
return errors
def error_function(program, debug=False):
errors = []
for case in cases:
interpreter = PushInterpreter()
output = interpreter.run(program, [case], ['_vector_boolean'], debug)[0]
target = invert_bitstring(case)
if output is None:
errors.append(1e5)
if not len(output) == len(target):
errors.append(1e4)
else:
errors.append(levenshtein_distance(output, target))
return errors
def error_function(program, debug=False):
errors = []
for case in training_set:
interpreter = PushInterpreter()
result = interpreter.run(program, case[0], ['_vector_integer'],
debug)[0]
if result is None:
errors.append(1e5)
else:
e = []
for i in range(min(len(result), len(case[1]))):
e.append(abs(result[i] - case[1][i]))
e.append(abs(len(result) - len(case[1])) * 100)
errors.append(sum(e))
def error_func(program):
errors = []
for x in range(10):
# Create the push interpreter
interpreter = PushInterpreter()
y_hat = interpreter.run(program, [x], ['_integer'])[0]
# Get output
if y_hat is None:
errors.append(1e5)
else:
# compare to target output
y_target = target_function(x)
# calculate error
errors.append(abs(y_hat - y_target))
return errors
def error_function(program):
errors = []
for case in cases:
interpreter = PushInterpreter()
output = interpreter.run(program, [case], ['_vector_integer'])[0]
target = [x - 1 for x in case]
if output is None:
errors.append(1e5)
elif len(output) != len(target):
errors.append(1e4)
else:
rmse = np.linalg.norm(np.array(output) -
np.array(target)) / np.sqrt(len(output))
errors.append(rmse)
return errors
def error_func(program):
errors = []
for x in range(10):
# Create the push interpreter and run program
interpreter = PushInterpreter()
y_hat = interpreter.run(program, inputs=[x],
output_types=['_integer'])[0]
# Get output
if y_hat is not None:
# compare to target output
target_int = target_function(x)
# calculate error
errors.append((y_hat - target_int)**2)
else:
errors.append(1e5)
return errors
def iris_error_func(program):
error_vec = []
for i in range(X_train.shape[0]):
interpreter = PushInterpreter()
outputs = interpreter.run(program, X_train[i],
['_float', '_float', '_float'])
not_none = [x for x in outputs if x is not None]
if len(not_none) == 0:
error_vec.append(1000000)
else:
y_hat = outputs.index(max(not_none))
if y_hat == y_train[i]:
error_vec.append(0)
else:
error_vec.append(1)
return error_vec
def __init__(self,
spawner: GeneSpawner,
search: str = "GA",
selector: Union[sl.Selector, str] = "lexicase",
variation_strategy: Union[vr.VariationStrategy, dict,
str] = "umad",
population_size: int = 300,
max_generations: int = 100,
initial_genome_size: Tuple[int, int] = (20, 100),
simplification_steps: int = 2000,
last_str_from_stdout: bool = False,
interpreter: PushInterpreter = "default",
parallelism: Union[int, bool] = False,
push_config: PushConfig = "default",
verbose: int = 0,
**kwargs):
self._search_name = search
self.spawner = spawner
self.selector = selector
self.variation_strategy = variation_strategy
self.population_size = population_size
self.max_generations = max_generations
self.initial_genome_size = initial_genome_size
self.simplification_steps = simplification_steps
self.last_str_from_stdout = last_str_from_stdout
self.parallelism = parallelism
self.verbose = verbose
self.ext = kwargs
set_verbosity(self.verbose)
# Initialize attributes that will be set later.
self.evaluator = None
self.signature = None
self.search = None
self.solution = None
if interpreter == "default":
self.interpreter = PushInterpreter()
else:
self.interpreter = interpreter
if push_config == "default":
self.push_config = PushConfig()
else:
self.push_config = push_config
def setUp(self):
self.i = PushInterpreter()
self.d = {
'_auxiliary': [],
'_boolean': [],
'_char': [],
'_code': [],
'_exec': [],
'_float': [],
'_input': ['a', 'b', 'c'],
'_integer': [],
'_string': [],
'_vector_boolean': [],
'_vector_float': [],
'_vector_integer': [],
'_vector_string': []
}
self.i.state.from_dict(self.d)
def test_inputs(core_type_lib, push_config):
interp = PushInterpreter()
in_state = PushState.from_dict({"inputs": [7, "x"], "int": []}, core_type_lib, push_config)
ex_state = PushState.from_dict({"inputs": [7, "x"], "int": [7]}, core_type_lib, push_config)
interp.state = in_state
interp.evaluate_atom(Input(input_index=0), push_config)
ac_state = interp.state
assert ex_state == ac_state
assert len(in_state.inputs) == 2
in_state = PushState.from_dict({"inputs": [7, "x"], "str": []}, core_type_lib, push_config)
ex_state = PushState.from_dict({"inputs": [7, "x"], "str": ["x"]}, core_type_lib, push_config)
interp.state = in_state
interp.evaluate_atom(Input(input_index=1), push_config)
ac_state = interp.state
assert ex_state == ac_state
assert len(in_state.inputs) == 2
def odd_error_func(program, debug=False):
errors = []
for i in range(10):
# Create the push interpreter
interpreter = PushInterpreter()
interpreter.state['_integer'].push(i)
# Run program
y_hat = interpreter.run(program, [i], ['_boolean'], debug)[0]
# Get output
if y_hat is None:
errors.append(1e5)
else:
# compare to target output
y = bool(i % 2)
if y_hat == y:
errors.append(0)
else:
errors.append(1)
return errors
def error_function(program):
errors = []
for case in cases:
interpreter = PushInterpreter()
output = interpreter.run(program, case, ['_boolean', '_boolean'])
targets = full_adder(case)
e = 0
if output[0] is None:
e += 1000
elif output[0] != targets[0]:
e += 1
if output[1] is None:
e += 1000
elif output[1] != targets[1]:
e += 1
errors.append(e)
return errors
def string_error_func(program):
inputs = [
"abcde", "", "E", "Hi", "Tom", "leprechaun", "zoomzoomzoom",
"qwertyuiopasd", "GallopTrotCanter", "Quinona", "_abc"
]
errors = []
for inpt in inputs:
# Create the push interpreter
interpreter = PushInterpreter()
y_hat = interpreter.run(program, [inpt], ['_string'])[0]
if y_hat is None:
errors.append(1e5)
else:
# compare to target output
target_output = inpt[:-2] + inpt[:-2]
errors.append(
string_difference(y_hat, target_output) +
string_char_counts_difference(y_hat, target_output))
return errors
def test_estimator_with_custom_types(point_cls, point_instr_set):
X = np.arange(-1.0, 1.0, 0.05).reshape(-1, 4)
y = [[point_distance(point_cls(x[0], x[1]), point_cls(x[2], x[3]))]
for x in X]
spawner = GeneSpawner(n_inputs=1,
instruction_set=point_instr_set,
literals=[],
erc_generators=[])
est = PushEstimator(
spawner=spawner,
population_size=30,
max_generations=3,
simplification_steps=2,
interpreter=PushInterpreter(point_instr_set),
)
est.fit(X, y)
assert isinstance(est.solution, Individual)
assert len(est.solution.program.code) > 0
def test_instructions(core_type_lib, push_config):
debug = False
interp = PushInterpreter()
iset = interp.instruction_set
for spec in SPECS:
in_state = PushState.from_dict(spec["in"], core_type_lib, push_config)
ex_state = PushState.from_dict(spec["ex"], core_type_lib, push_config)
interp.state = in_state
instruction_name = spec["instr"]
if debug:
print(instruction_name,)
in_state.pretty_print()
print("---")
ex_state.pretty_print()
print("---")
interp.evaluate_atom(iset[instruction_name].meta(), push_config)
ac_state = interp.state
if debug:
ac_state.pretty_print()
print()
assert ex_state == ac_state
.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(
spawner=spawner,
population_size=300,
max_generations=20,
simplification_steps=500,
interpreter=PushInterpreter(instruction_set),
verbose=2
)
if __name__ == "__main__":
est.fit(X, y)
print(est.solution.program)
print(est.predict(X))
print(est.score(X, y))
def test_genome_point_dist(point_instr_set):
check_translation("point_distance", PushInterpreter(point_instr_set))
def check_unary_fn_translation(program_name: str):
interpreter = PushInterpreter(InstructionSet(register_core=True))
check_translation(program_name, interpreter)
def setUp(self):
self.i = PushInterpreter()
def interpreter():
return PushInterpreter()