def evaluate_individual_impl(toolbox, ind, debug=0):
if True:
# cpp interpretatie en evaluatie
raw_error_matrix, family_key = cpp_coupling.compute_error_matrix(toolbox.cpp_handle, ind, \
toolbox.penalise_non_reacting_models, toolbox.families_dict, toolbox.family_key_is_error_matrix)
else:
if False:
# cpp interpretatie
model_outputs = cpp_coupling.run_on_all_inputs(
toolbox.cpp_handle, ind)
else:
# python interpretatie
code = interpret.compile_deap(str(ind), toolbox.functions)
toolbox.functions[toolbox.problem_name] = [
toolbox.formal_params, code
]
model_outputs = []
for input in toolbox.example_inputs:
model_output = interpret.run([toolbox.problem_name] + input,
dict(),
toolbox.functions,
debug=toolbox.verbose >= 5)
model_outputs.append(model_output)
family_key = evaluate.recursive_tuple(model_outputs)
# python evaluatie
if family_key not in toolbox.families_dict:
raw_error_matrix = evaluate.compute_raw_error_matrix(toolbox.example_inputs, model_outputs, toolbox.error_function, \
toolbox.f,toolbox.verbose, toolbox.penalise_non_reacting_models)
# bepaling family
if family_key in toolbox.families_dict:
family_index = toolbox.families_dict[family_key]
ind.fam = toolbox.families_list[family_index]
if ind.fam.representative is None or len(
ind.fam.representative) > len(ind):
#if ind.fam.raw_error <= toolbox.max_raw_error_for_family_db:
# toolbox.f.write(f"at gen {toolbox.real_gen}, found shorter representative of {get_fam_info(ind.fam)}\n")
ind.fam.representative = ind # keep shortest representative
else:
family_index = len(toolbox.families_list)
toolbox.families_dict[family_key] = family_index
ind.fam = Family(family_index, raw_error_matrix, ind)
toolbox.families_list.append(ind.fam)
#if ind.fam.raw_error <= toolbox.max_raw_error_for_family_db:
# toolbox.f.write(f"at gen {toolbox.real_gen}, new fam {get_fam_info(ind.fam)}\n")
if ind.fam.raw_error <= toolbox.max_raw_error_for_family_db:
toolbox.new_families_list.append(ind.fam)
# piggyback test : vergelijk uitkomst cpp met python implementatie
if False:
model_outputs_py = cpp_coupling.run_on_all_inputs(
toolbox.cpp_handle, ind)
raw_error_matrix_py = evaluate.compute_raw_error_matrix(toolbox.example_inputs, model_outputs_py, toolbox.error_function, \
toolbox.f, debug, toolbox.penalise_non_reacting_models)
check_error_matrices(raw_error_matrix_py, raw_error_matrix)
def test_against_python_interpreter(toolbox, cpp_model_outputs, ind):
code = interpret.compile_deap(str(ind), toolbox.functions)
toolbox.functions[toolbox.problem_name] = [toolbox.formal_params, code]
py_model_outputs = []
for input in toolbox.example_inputs:
model_output = interpret.run([toolbox.problem_name] + input,
dict(),
toolbox.functions,
debug=toolbox.verbose >= 5)
py_model_outputs.append(model_output)
if py_model_outputs != cpp_model_outputs:
cpp_coupling.run_on_all_inputs(toolbox.cpp_handle, ind, debug=2)
print("py_model_outputs", py_model_outputs)
print("cpp_model_outputs", cpp_model_outputs)
print("toolbox.eval_count OK", toolbox.eval_count - 1)
code_str = interpret.convert_code_to_str(code)
print(code_str)
assert py_model_outputs == cpp_model_outputs
def _append(self, code_tree, tree_depth, tree_size, params, unassigned_locals):
self.log_file.write(f"L{self.L}D{self.D} _append({str(code_tree)})\n")
if self.verbose >= 1:
if time.time() > self.last_time + 10:
self.last_time = time.time()
print(f"L{self.L}D{self.D} _append", code_tree, "new_code_trees size", len(self.new_code_trees), "new_families size", len(self.new_families))
if len(unassigned_locals) == 0:
if len(params) == 0 and tree_depth > 1:
# skip constant code
pass
else:
# We can run this code, do family optimization
model_outputs = []
first, first_model_output, all_equal_to_first = True, None, True
for input in self.example_inputs:
variables = interpret.bind_params(self.parameters[:len(input)], input)
model_output = interpret.run(code_tree, variables, self.old_functions)
if first:
first = False
first_model_output = model_output
elif first_model_output != model_output:
all_equal_to_first = False
model_outputs.append(model_output)
model_outputs_tuple = recursive_tuple(model_outputs)
if model_outputs_tuple not in self.family_size:
self.family_size[model_outputs_tuple] = 0
self.is_constant_family[model_outputs_tuple] = all_equal_to_first
self.family_size[model_outputs_tuple] += 1
if model_outputs_tuple in self.old_families:
pass
else:
if model_outputs_tuple not in self.new_families:
self.new_families[model_outputs_tuple] = (code_tree, tree_depth, tree_size, params, unassigned_locals)
else:
_, _, stored_tree_size, _, _ = self.new_families[model_outputs_tuple]
if stored_tree_size > tree_size:
self.new_families[model_outputs_tuple] = (code_tree, tree_depth, tree_size, params, unassigned_locals)
else:
# We cannot run this code, no family optimization possible
self.new_code_trees.append([code_tree, tree_depth, tree_size, params, unassigned_locals])
def is_solved_by_function(example_inputs, error_function, fname, functions,
log_file, verbose):
actual_outputs = []
if fname in functions:
formal_params = functions[fname]
arity = len(formal_params)
else:
arity = len(interpret.get_build_in_function_param_types(fname))
used_example_inputs = []
for input in example_inputs:
if len(input) == arity:
used_example_inputs.append(input)
code = [fname] + input
variables = dict()
actual_output = interpret.run(code, variables, functions)
actual_outputs.append(actual_output)
if len(used_example_inputs) == 0:
return False
raw_error_matrix = evaluate.compute_raw_error_matrix(
used_example_inputs, actual_outputs, error_function, log_file, verbose,
False)
return np.sum(raw_error_matrix) <= 0.0
import sys
import translate
import interpret
if len(sys.argv) == 2:
translated = translate.translate(sys.argv[1])
# To display parsed version (for debugging), uncomment line below
# print("\n".join(map(str,translated)))
interpret.run(translated)
else:
print("❌🤔📜❔❔")
def evaluate(agenda, definitions, scope):
# print lispio.write(syntax.expand_toplevel(definitions))
keeper = initialscope.ComplainingKeeper()
expr = syntax.expand_toplevel(definitions)
interpret.run(agenda, keeper, expr, scope)
def entry_point(argv):
jit.set_param(None, "trace_limit", 20000)
interpret.run(argv)
return 0
