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())