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)