def optimistic_stream_grounding(stream_instance, bindings, evaluations, opt_evaluations, immediate=False): # TODO: combination for domain predicates evaluation_set = set(evaluations) opt_instances = [] input_objects = [ bindings.get(i, [i]) for i in stream_instance.input_objects ] for combo in product(*input_objects): mapping = dict(zip(stream_instance.input_objects, combo)) domain = set( map(evaluation_from_fact, substitute_expression( stream_instance.get_domain(), mapping))) # TODO: could just instantiate first if domain <= opt_evaluations: instance = stream_instance.external.get_instance(combo) if (instance.opt_index != 0) and (not immediate or (domain <= evaluation_set)): instance.opt_index -= 1 opt_instances.append(instance) return opt_instances
def __init__(self, instance, output_objects, opt_index=None): super(StreamResult, self).__init__(instance, opt_index) self.output_objects = tuple(output_objects) self.mapping = dict( zip(self.instance.external.outputs, self.output_objects)) self.mapping.update(instance.mapping) self.certified = substitute_expression( self.instance.external.certified, self.get_mapping())
def __init__(self, external, input_objects): self.external = external self.input_objects = tuple(input_objects) self.enumerated = False self.disabled = False self.opt_index = 0 self.total_calls = 0 self.total_overhead = 0 self.total_successes = 0 self.results_history = [] self.mapping = dict(zip(self.external.inputs, self.input_objects)) for constant in self.external.constants: self.mapping[constant] = Object.from_name(constant) self.domain = substitute_expression(self.external.domain, self.get_mapping())
def ground_stream_instances(stream_instance, bindings, evaluations, opt_evaluations, plan_index): # TODO: combination for domain predicates evaluation_set = set(evaluations) combined_evaluations = evaluation_set | opt_evaluations real_instances = [] opt_instances = [] input_objects = [ bindings.get(i, [i]) for i in stream_instance.input_objects ] for combo in product(*input_objects): mapping = dict(zip(stream_instance.input_objects, combo)) domain = set( map(evaluation_from_fact, substitute_expression(stream_instance.get_domain(), mapping))) if domain <= combined_evaluations: instance = stream_instance.external.get_instance(combo) immediate = False if immediate: if domain <= evaluation_set: if instance.opt_index == 0: real_instances.append(instance) else: instance.opt_index -= 1 opt_instances.append(instance) else: opt_instances.append(instance) else: #if (instance.opt_index == 0) and (domain <= evaluation_set): if (plan_index == 0) and (domain <= evaluation_set): real_instances.append(instance) else: if instance.opt_index != 0: instance.opt_index -= 1 opt_instances.append(instance) return real_instances, opt_instances
def get_synth_stream(self, stream_plan): key = frozenset(stream_plan) if key in self.macro_results: return self.macro_results[key] param_from_obj = {} macro_from_micro = [] inputs, domain, outputs, certified = [], set(), [], set() input_objects, output_objects = [], [] functions = set() streams = [] for result in stream_plan: local_mapping = {} stream = result.instance.external for inp, input_object in zip(stream.inputs, result.instance.input_objects): # TODO: only do optimistic parameters? # if isinstance() if input_object not in param_from_obj: param_from_obj[input_object] = '?i{}'.format(len(inputs)) inputs.append(param_from_obj[input_object]) input_objects.append(input_object) local_mapping[inp] = param_from_obj[input_object] domain.update( set(substitute_expression(stream.domain, local_mapping)) - certified) if isinstance(result, PredicateResult): # functions.append(Equal(stream.head, result.value)) mapping = { inp: param_from_obj[inp] for inp in result.instance.input_objects } functions.update( substitute_expression(result.get_certified(), mapping)) elif isinstance(result, FunctionResult): functions.add( substitute_expression(Minimize(stream.head), local_mapping)) else: for out, output_object in zip(stream.outputs, result.output_objects): if output_object not in param_from_obj: param_from_obj[output_object] = '?o{}'.format( len(outputs)) outputs.append(param_from_obj[output_object]) output_objects.append(output_object) local_mapping[out] = param_from_obj[output_object] certified.update( substitute_expression(stream.certified, local_mapping)) streams.append(stream) macro_from_micro.append(local_mapping) gen_fn = self.get_gen_fn(inputs, outputs, certified | functions) mega_stream = SynthStream(self, gen_fn, inputs=tuple(inputs), domain=domain, outputs=tuple(outputs), certified=certified, streams=streams, macro_from_micro=macro_from_micro) mega_instance = mega_stream.get_instance(input_objects) self.macro_results[key] = SynthStreamResult(mega_instance, output_objects) return self.macro_results[key]
def new_gen_fn(*input_values): assert (len(inputs) == len(input_values)) mapping = dict(zip(inputs, input_values)) targets = substitute_expression(certified, mapping) return self.gen_fn(outputs, targets) # TODO: could also return a map
def get_head(self): return substitute_expression(self.external.head, self.get_mapping())