def get_optimal_refinement(**kwargs): initsol = kwargs['initsol'] parent = kwargs['parent'] prior = kwargs['prior'] # added below contains the as_string value for each clause added in refined. # It's used as set of 'keys' to filter duplicates refined,added = [],[] if 'search_space_size' not in kwargs: for c in parent.support: use_dict = analyze_use_3(parent,c,prior) use_3 = asp.find_all_optimal() print(use_3) if use_3 != []: (_,revisable) = functs.filter_retained_(use_3,use_dict) for (clause_index,clause) in revisable: revcl = functs.form_revised_(clause_index,clause,use_dict,use_3) revcl = structs.Clause(revcl,gl) #refined.append((clause,revcl)) if not revcl.as_string in added: added.append(revcl.as_string) refined.append(revcl) else: pass if list(set(added)) == [initsol.as_string]: # then we have a problem: All we could find is the initial refinement # which does not subsume the support set. We'll try to split the initial # refinement. To do that, we repeat the above process, but this time we # increase the size of the fragment of the support set that is used as # search space. We do that calling this method again with an optional # argument that specifies how many support clauses shall be used simultaneously # as search space: kwargs.update({'search_space_size':'2'}) return get_optimal_refinement(**kwargs) # this is buggy (and doesn't fully work): # opt = subsumption.find_minimal_subsuming_subset(refined,parent.support,found_initial=True) else: opt = subsumption.find_minimal_subsuming_subset(refined,parent.support) update_support((parent,opt)) return opt else: pass """
def revise(**kwargs): hs,scs,cls = kwargs['heuristic_search'],kwargs['set_cover_search'],kwargs['clause_level_search'] special_search = scs or cls if not special_search: gl.use_dict = {} is_new_example = kwargs['is_new_example'] debug_mode = kwargs['debug'] if 'debug' in kwargs else False # keep this optional retained,new,refined = kwargs['retcl'],kwargs['newcl'],kwargs['refcl'] if debug_mode: import debug_utils prior_theory = debug_utils.py_load_from_file() else: prior_theory = [retained,new,refined] prior_theory_ = [x for y in prior_theory for x in y] if is_new_example: #retained.extend(refined) # that's a patch because due to a bug previously refined clauses are left out generate_kernel(**kwargs) if gl.runargs["kernel-set-only"]: # We only need to generate a kernel set sys.exit() var_kernel = gl.current_var_kernel if 'search_subsets' in kwargs: search_kernel_by_subsets(prior_theory_) elif 'incremental_solve' in kwargs and kwargs['incremental_solve']: (solution,use_2,use_3) = incremental_solve(var_kernel,prior_theory_) else: analyze_use_try(gl.current_var_kernel,prior_theory_) out = asp.ind(kernel_generalization=True) (use_2,use_3) = functs.split_use_2_3(out) (ok,use_head_body_map) = functs.head_body_use_atoms_filter(use_2) if ok : new = form_new_clauses(use_head_body_map) else: msg = 'Found a solution use(i,j) atom with no corresponding use(i,0) atom' raise excps.Use_2_HeadNotAbducedException(msg,gl.logger) (retained,revisable) = functs.filter_retained_(use_3,gl.use_dict) update_support(retained) else: # re-seeing past example #prior_theory = [retained,refined] # Only analyze the new clauses generated last. # Update This is messy...Analyze it all, there is no serious overhead #analyze_use_try([],new,preserve=[x for y in prior_theory for x in y]) analyze_use_try([],prior_theory_) out = asp.ind(recheck_hist_memory=True) (_,use_3) = functs.split_use_2_3(out) # no use/2 here (retained,revisable) = functs.filter_retained_(use_3,gl.use_dict) revisable_ = [] for (clause_index,clause) in revisable: #import debug_utils #debug_utils.check_on_previous() revcl = functs.form_revised_(clause_index,clause,gl.use_dict,use_3) revcl = structs.Clause(revcl,gl) revisable_.append((clause,revcl)) incorrects = [inx[0] for inx in revisable_] specialized = [] for (incorrect,one_solution) in revisable_ : # need to find optimal refinement optimal_ref = one_solution check_prior = [z for z in prior_theory_ if not z in incorrects] if search_more(initsol=one_solution,parent=incorrect,prior=check_prior): other_init_solutions = [x[1] for x in revisable_ if x[1] != one_solution] check_prior.extend(other_init_solutions) optimal_ref = get_optimal_refinement(initsol=one_solution, parent=incorrect, prior=check_prior) if isinstance(optimal_ref,list): # then it went through get_optimal_refinement because that returns a list specialized.extend(optimal_ref) else: if isinstance(optimal_ref,structs.Clause): # then it's the initial solution, no support update yet update_support((incorrect,optimal_ref))# this must be passed as a (parent,child) tuple specialized.append(optimal_ref) #d = dict(zip(incorrects,specialized)) if is_new_example: (n,r,s) = (new,retained,specialized) else: (n,r,s) = ([],retained,specialized) updateprior(n,r,s) return (n,r,s) else: if kwargs['set_cover_search']: return set_cover_search(**kwargs) elif kwargs['heuristic_search']: return heuristic_search(**kwargs) else: #return incremental_kernel_search.incremental_search(**kwargs) return incremental_kernel_search(**kwargs)