def make_initial_state(task):
valuation = dict(task.default_valuation()) # needs to be a full one!
for branch in task.network.branches:
valuation[branch.closed.index] = branch.init_closed
return State(task, [(x, v) for x, v in valuation.iteritems()])
def make_initial_state(task):
valuation = dict(task.default_valuation()) # needs to be a full one!
for switch in task.network.TECircuitbreakerLines + task.network.TERDeviceLines + task.network.TEMDeviceLines:
valuation[switch.closed.index] = switch.start_closed
return State(task, [(x, v) for x, v in valuation.iteritems()])
def populate_informed( self, projected_task, vars_maps, actions_maps, h ) :
from itertools import product
from model.generic.planning.task import State
def optimal_search( task, h ) :
from search import astar_search
from search.a_star import ordered_node_astar
from heuristics.h_zero import H_Zero
h.enable_preferred_ops = False
def heuristic_adapter( node ) :
_, inv_var_map = vars_maps
node.state.primary.unprojected = [ (inv_var_map[X],v) for X,v in node.state.primary.iter_values() ]
return h(node)
return astar_search( task, heuristic_adapter, make_open_entry=ordered_node_astar, use_relaxed_plan=False, mute=True )
var_map, inv_var_map = vars_maps
action_map, inv_action_map = actions_maps
domains = [ x.domain for x in projected_task.task.state_vars ]
value_index = 0
self.unsolvable_count = 0
self.num_non_zero_entries = 0
self.max_value = 0
for valuation in apply(product, map(tuple,domains) ) :
value_index += 1
# indexed with the original vars
entry_index = tuple([ ( inv_var_map[x], v) for x, v in enumerate(valuation) ])
s0 = State( projected_task.task, [ (x,v) for x,v in enumerate(valuation) ] )
projected_task.set_initial_state( s0 )
projected_task.initial_state.check_valid()
if not projected_task.initial_state.valid :
self.table[ entry_index ] = Entry( float('inf'), None )
self.unsolvable_count += 1
continue
solution = optimal_search( projected_task, h )
if solution==None:
plan = None
final_state = None
else:
plan, final_state = solution
if plan is None :
self.table[ entry_index ] = Entry( float('inf'), None )
self.unsolvable_count += 1
continue
first_action_in_plan = None
if len(plan) > 0 :
self.num_non_zero_entries += 1
first_action_in_plan = inv_action_map[plan[0].index]
self.table[ entry_index ] = Entry( final_state.g, first_action_in_plan )
self.max_value = max( self.max_value, final_state.g )
def make_initial_state(task, initial_values):
valuation = dict(task.default_valuation())
for c, v in initial_values:
for k in xrange(v, -1, -1):
valuation[task.counter_values[c][k].index] = True
for k in xrange(v + 1, task.max_value):
valuation[task.counter_values[c][k].index] = False
return State(task, [(x, v) for x, v in valuation.iteritems()])
def make_initial_state(task, initial_values):
valuation = dict(task.default_valuation())
for c, v in initial_values:
x = None
for y in task.state_vars:
if c in y.name:
x = y
break
valuation[x.index] = v
return State(task, [(x, v) for x, v in valuation.items()])
def populate_sdac( self, projected_task, vars_maps, actions_maps ) :
from itertools import product
from search.breadth_first_search import breadth_first_search_sdac
from model.generic.planning.task import State
var_map, inv_var_map = vars_maps
action_map, inv_action_map = actions_maps
domains = [ x.domain for x in projected_task.task.state_vars ]
value_index = 0
self.unsolvable_count = 0
self.num_non_zero_entries = 0
self.max_value = 0
for valuation in apply(product, map(tuple,domains) ) :
value_index += 1
# indexed with the original vars
entry_index = tuple([ ( inv_var_map[x], v) for x, v in enumerate(valuation) ])
s0 = State( projected_task.task, [ (x,v) for x,v in enumerate(valuation) ] )
projected_task.set_initial_state( s0 )
projected_task.initial_state.check_valid()
if not projected_task.initial_state.valid :
self.table[ entry_index ] = Entry( float('inf'), None )
self.unsolvable_count += 1
continue
#solution = breadth_first_search_sdac( projected_task, True )
solution = astar_search(projected_task, H_Zero(projected_task))
if solution==None:
plan = None
final_state = None
else:
plan, final_state = solution
print("plan : ",plan, " final_state : ",final_state)
if plan is None :
self.table[ entry_index ] = Entry( float('inf'), None )
self.unsolvable_count += 1
continue
first_action_in_plan = None
if len(plan) > 0 :
self.num_non_zero_entries += 1
print("inv_action_map",inv_action_map)
print("first_action_in_plan : ",plan[0].name)
print("first_action_in_plan : ",inv_action_map[plan[0].index])
first_action_in_plan = inv_action_map[plan[0].index]
self.table[ entry_index ] = Entry( final_state.g, first_action_in_plan )
self.max_value = max( self.max_value, len(plan) )
logging.info( '# of infinite entries in pattern: {0}'.format( self.unsolvable_count ) )
logging.info( '# of entries with a value greater than 0: {0}'.format(self.num_non_zero_entries) )
logging.info( 'Maximum value in pattern: {0}'.format( self.max_value ) )
def make_initial_state(instream, task, orig_num_cylinders):
# 1. initialize all to False
# 2. initialize actual values
input_line = instream.readline()
facts = set()
while 'goal' not in input_line:
decode_vars(task, input_line, facts)
input_line = instream.readline()
# determine values for task variables
valuation = dict()
if 'gripper_empty' in facts:
valuation[task.gripper_empty.index] = True
for k in xrange(task.objects.num_blocks()):
if block_clear(k) in facts:
valuation[task.block_clear[k].index] = True
for l in xrange(task.objects.num_cylinders()):
valuation[task.cylinder_empty[l].index] = True
for k in xrange(task.objects.num_blocks()):
for l in xrange(task.objects.num_cylinders()):
if block_in_cylinder(k, l) in facts:
valuation[task.block_container[k].
index] = task.block_container_values[in_cylinder(l)]
valuation[task.cylinder_empty[l].index] = False
break
for k in xrange(task.objects.num_blocks()):
is_on_block = False
for l in xrange(task.objects.num_blocks()):
if block_on_block(k, l) in facts:
valuation[task.block_position[k].
index] = task.block_position_values[on_block(l)]
valuation[task.block_clear[l].index] = False
is_on_block = True
break
if is_on_block: continue
is_on_piston = False
for l in xrange(task.objects.num_cylinders()):
if block_on_piston(k) in facts:
valuation[task.block_position[k].
index] = task.block_position_values['on_piston']
is_on_piston = True
break
if is_on_piston: continue
assert False
print([(task.state_vars[x].name, v) for x, v in valuation.iteritems()])
return State(task, [(x, v) for x, v in valuation.iteritems()])
def make_initial_state(instream, task, orig_num_cylinders):
# 1. initialize all to False
valuation = dict(task.default_valuation()) # needs to be a full one!
# 2. initialize actual values
input_line = instream.readline()
while 'goal' not in input_line:
valuation[decode_var(task, input_line)] = True
input_line = instream.readline()
if orig_num_cylinders == 2:
valuation[task.cylinder_empty[2].index] = True
print([(task.state_vars[x].name, v) for x, v in valuation.iteritems()])
return State(task, [(x, v) for x, v in valuation.iteritems()])
def make_initial_state(self):
valuation = []
depot = self.locations[0]
for (vname, _, _, _) in self.vehicles:
var = self.at[vname]
valuation.append((var.index, depot))
for loc in self.locations[1:]:
var = self.visited[(vname, loc)]
valuation.append((var.index, False))
if LinehaulTask.SYMMETRY_BREAKING:
for vtype in self.vehicle_type.values():
var = self.vehicle_type_used[vtype]
valuation.append((var.index, False))
return State(self, valuation)
def make_state(self, valuation):
return State(self, valuation)
