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