def _ground_actions(actions, obj_means, constraints, signs, agents,
agent_type):
events = []
# ground actions
for action_name, smaller in actions.items():
if not action_name in signs:
act_sign = Sign(action_name)
signs[action_name] = act_sign
act_signif = act_sign.add_significance()
else:
act_sign = signs[action_name]
act_signif = act_sign.add_significance()
for part, decription in smaller.items():
effect = True
if part == "cause": effect = False
for predicate, signature in decription.items():
if len(signature['cause']) > 1:
pred = get_predicate(predicate, signature, signs)
if pred:
connector = act_signif.add_feature(pred, effect=effect)
pred.sign.add_out_significance(connector)
else:
raise Exception(
"predicate *{0}* has wrong definition in action *{1}*"
.format(predicate, action_name))
elif len(signature['cause']) == 1:
pred = signs[predicate].significances[1]
connector = act_signif.add_feature(pred, effect=effect)
pred.sign.add_out_significance(connector)
role_sign = signs[signature["cause"][0]]
conn = act_signif.add_feature(role_sign.significances[1],
connector.in_order,
effect=effect)
role_sign.add_out_significance(conn)
if not constraints:
for ag in agents:
act_mean = act_signif.copy('significance', 'meaning')
ag_sign = signs[ag]
act_mean.replace('meaning', signs[agent_type],
obj_means[ag_sign])
connector = act_mean.add_feature(obj_means[ag_sign])
efconnector = act_mean.add_feature(obj_means[ag_sign],
effect=True)
events.append(act_mean.effect[abs(efconnector.in_order) - 1])
ag_sign.add_out_meaning(connector)
else:
events.extend(constr_replace(constraints, act_signif, agents))
return events
def create_situation(name, predicates):
sign = Sign(name)
signif = sign.add_significance()
for pred in predicates:
connector = signif.add_feature(pred.significances[1])
pred.add_out_significance(connector)
return sign
def signify_connection(signs):
Send = Sign("Send")
send_signif = Send.add_significance()
Broadcast = Sign("Broadcast")
brdct_signif = Broadcast.add_significance()
connector = brdct_signif.add_feature(send_signif)
Send.add_out_significance(connector)
Approve = Sign("Approve")
approve_signif = Approve.add_significance()
connector = approve_signif.add_feature(send_signif)
Send.add_out_significance(connector)
signs[Send.name] = Send
signs[Broadcast.name] = Broadcast
signs[Approve.name] = Approve
They_sign = signs["They"]
They_signif = They_sign.add_significance()
brdct_signif = Broadcast.add_significance()
connector = They_signif.add_feature(brdct_signif)
Broadcast.add_out_significance(connector)
approve_signif = Approve.add_significance()
They_signif = They_sign.add_significance()
connector = They_signif.add_feature(approve_signif)
Approve.add_out_significance(connector)
brdct_signif = Broadcast.add_significance()
executer = brdct_signif.add_feature(Broadcast.name.lower(), effect=True, actuator=True)
Send.add_out_significance(executer)
approve_signif = Approve.add_significance()
executer = approve_signif.add_feature(Approve.name.lower(), effect=True, actuator=True)
Send.add_out_significance(executer)
def __add_sign(sname, need_signif=True):
if sname in signs:
sign = signs[sname]
else:
sign = Sign(sname)
signs[sname] = sign
if need_signif:
obj_signifs[sign] = sign.add_significance()
return sign
def update_single(facts):
for fact in facts:
role_name = fact[1][0].name + fact[0]
fact_name = fact[1][0].name
if role_name not in signs:
role_sign = Sign(role_name)
signs[role_name] = role_sign
else:
role_sign = signs[role_name]
if fact_name not in signs:
fact_sign = Sign(fact_name)
signs[fact_name] = fact_sign
else:
fact_sign = signs[fact_name]
role_signif = role_sign.add_significance()
fact_signif = fact_sign.add_significance()
connector = role_signif.add_feature(fact_signif, zero_out=True)
fact_sign.add_out_significance(connector)
def signify_connection(signs):
Send = Sign("Send")
send_signif = Send.add_significance()
Broadcast = Sign("Broadcast")
brdct_signif = Broadcast.add_significance()
connector = brdct_signif.add_feature(send_signif)
Send.add_out_significance(connector)
Approve = Sign("Approve")
approve_signif = Approve.add_significance()
connector = approve_signif.add_feature(send_signif)
Send.add_out_significance(connector)
signs[Send.name] = Send
signs[Broadcast.name] = Broadcast
signs[Approve.name] = Approve
They_sign = signs["They"]
agents = They_sign.spread_up_activity_obj("significance", 1)
agents_type = []
for agent in agents:
agents_type.append({
cm.sign
for cm in agent.sign.spread_up_activity_obj("significance", 1)
})
types = []
if agents_type:
types = [
t for t in reduce(lambda x, y: x & y, agents_type)
if t != signs["object"]
]
if types and len(agents):
type = types[0]
else:
type = signs["I"]
They_signif = They_sign.add_significance()
brdct_signif = Broadcast.add_significance()
connector = They_signif.add_feature(brdct_signif)
Broadcast.add_out_significance(connector)
type_signif = type.add_significance()
approve_signif = Approve.add_significance()
connector = type_signif.add_feature(approve_signif)
Approve.add_out_significance(connector)
brdct_signif = Broadcast.add_significance()
executer = brdct_signif.add_feature(Broadcast.name.lower(),
effect=True,
actuator=True)
Send.add_out_significance(executer)
approve_signif = Approve.add_significance()
executer = approve_signif.add_feature(Approve.name.lower(),
effect=True,
actuator=True)
Send.add_out_significance(executer)
def signify_actions(actions, constraints, signs, agent, obj_means,
obj_signifs):
for action in actions:
act_sign = Sign(action.name)
act_signif = act_sign.add_significance()
def update_significance(predicate, signature, effect=False):
pred_sign = signs[predicate.name]
if len(pred_sign.significances) > 1:
pred_cm = pred_resonate('significance', pred_sign, predicate,
signs, signature)
elif len(pred_sign.significances) == 0:
pred_cm = pred_sign.add_significance()
else:
pred_cm = pred_sign.significances[1]
connector = act_signif.add_feature(pred_cm, effect=effect)
pred_sign.add_out_significance(connector)
if len(predicate.signature) == 1:
fact = predicate.signature[0]
role_sign = signs[fact[1][0].name + fact[0]]
conn = act_signif.add_feature(role_sign.significances[1],
connector.in_order,
effect=effect,
zero_out=True)
role_sign.add_out_significance(conn)
elif not len(predicate.signature) == 0:
if not predicate.signature[0][1][
0].name == predicate.signature[1][1][0].name:
for role_sign in pred_cm.get_signs():
connector_new = act_signif.add_feature(
role_sign.significances[1],
connector.in_order,
effect=effect,
zero_out=True)
role_sign.add_out_significance(connector_new)
for predicate in action.precondition:
update_significance(predicate, action.signature, False)
for predicate in action.effect.addlist:
update_significance(predicate, action.signature, True)
signs[action.name] = act_sign
if constraints:
if not action.agents:
nonspecialized(constraints, act_signif, signs, agent,
obj_means, obj_signifs)
else:
specialized(action, signs, obj_means, obj_signifs, act_signif,
agent, constraints)
else:
simple(signs, obj_means, act_signif)
def save_plan(self, start, finish, actions, plan_name):
# Creating plan action for further use
if not plan_name:
plan_name = 'plan_' + self.name
if not start.sign.meanings:
scm = start.copy('image', 'meaning')
start.sign.add_meaning(scm)
for con in start.sign.out_meanings.copy():
if con.in_sign.name == plan_name:
start.sign.out_meanings.remove(con)
if not finish.sign.meanings:
fcm = finish.copy('image', 'meaning')
finish.sign.add_meaning(fcm)
for con in finish.sign.out_meanings.copy():
if con.in_sign.name == plan_name:
finish.sign.out_meanings.remove(con)
plan_sign = Sign(plan_name + self.name)
plan_mean = plan_sign.add_meaning()
connector = plan_mean.add_feature(start.sign.meanings[1])
start.sign.add_out_meaning(connector)
conn = plan_mean.add_feature(finish.sign.meanings[1], effect=True)
finish.sign.add_out_meaning(conn)
self.signs[plan_sign.name] = plan_sign
# Adding Sequence of actions to plan image
plan_image = plan_sign.add_image()
for act in actions:
im = act.sign.add_image()
connector = plan_image.add_feature(im)
act.sign.add_out_image(connector)
# Adding scenario vs partly concrete actions to the plan sign
scenario = self.scenario_builder(start, finish, actions)
plan_signif = plan_sign.add_significance()
for act in scenario:
connector = plan_signif.add_feature(act)
act.sign.add_out_significance(connector)
return [plan_sign, start.sign, finish.sign]
def spatial_ground(problem, plagent, agents, exp_signs=None, backward = False):
global signs
initial_state = problem.initial_state
initial_state.update(problem.map)
goal_state = problem.goal_state
goal_state.update(problem.map)
# Prepare states to plagent
init_state = {key: value for key, value in deepcopy(initial_state).items() if key != plagent}
init_state['I'] = initial_state[plagent]
init_state['objects']['I'] = init_state['objects'].pop(plagent)
go_state = {key: value for key, value in deepcopy(goal_state).items() if key != plagent}
go_state['I'] = goal_state[plagent]
go_state['objects']['I'] = go_state['objects'].pop(plagent)
agents.remove(plagent)
agents.append('I')
obj_signifs = {}
obj_means = {}
# Create agents and communications
agent_type = None
types = problem.domain['types']
roles = problem.domain['roles']
if exp_signs:
signs, types = ut._clear_model(exp_signs, signs, types)
signs, roles = ut._clear_model(exp_signs, signs, roles)
I_sign = exp_signs['I']
signs['I'] = I_sign
They_sign = exp_signs['They']
signs['They'] = They_sign
Clarify = exp_signs['Clarify']
signs['Clarify'] = Clarify
Abstract = exp_signs['Abstract']
signs['Abstract'] = Abstract
signs['situation'] = exp_signs['situation']
else:
I_sign = Sign("I")
They_sign = Sign("They")
obj_means[I_sign] = I_sign.add_meaning()
obj_signifs[I_sign] = I_sign.add_significance()
signs[I_sign.name] = I_sign
obj_means[They_sign] = They_sign.add_meaning()
obj_signifs[They_sign] = They_sign.add_significance()
signs[They_sign.name] = They_sign
Clarify = Sign('Clarify')
signs[Clarify.name] = Clarify
Abstract = Sign('Abstract')
signs[Abstract.name] = Abstract
signs['situation'] = Sign('situation')
# ground types
for type_name, smaller in types.items():
if not type_name in signs and not exp_signs:
type_sign = Sign(type_name)
signs[type_name] = type_sign
else:
if exp_signs:
type_sign = exp_signs[type_name]
else:
type_sign = signs[type_name]
if smaller:
for obj in smaller:
if not obj in signs:
obj_sign = Sign(obj)
signs[obj] = obj_sign
else:
obj_sign = signs[obj]
obj_signif = obj_sign.add_significance()
obj_signifs[obj_sign] = obj_signif
tp_signif = type_sign.add_significance()
connector = tp_signif.add_feature(obj_signif, zero_out=True)
obj_sign.add_out_significance(connector)
# Assign I to agent
if obj_sign.name == plagent:
connector = obj_signif.add_feature(obj_signifs[I_sign], zero_out=True)
I_sign.add_out_significance(connector)
agent_type = type_name
else:
obj_signifs[type_sign] = type_sign.add_significance()
# Assign other agents
others = {signs[ag] for ag in agents if ag != 'I'}
for subagent in others:
if not They_sign in subagent.significances[1].get_signs():
signif = obj_signifs[They_sign]
if signif.is_empty():
They_signif = signif
else:
They_signif = They_sign.add_significance()
connector = subagent.significances[1].add_feature(They_signif, zero_out=True)
They_sign.add_out_significance(connector)
obj_means[subagent] = subagent.add_meaning()
# Signify roles
for role_name, smaller in roles.items():
role_sign = Sign(role_name)
signs[role_name] = role_sign
for object in smaller:
obj_sign = signs[object]
obj_signif = obj_sign.significances[1]
role_signif = role_sign.add_significance()
connector = role_signif.add_feature(obj_signif, zero_out=True)
obj_sign.add_out_significance(connector)
if object == agent_type:
agent_type = role_name
# Find and signify walls
if exp_signs:
if not 'wall' in signs:
signs['wall'] = exp_signs['wall']
ws = signs['wall']
views = []
if ws.images:
for num, im in ws.images.items():
if len(im.cause):
for view in im.cause[0].coincidences:
if view.view:
views.append(view.view)
if 'wall' in problem.map:
for wall in problem.map['wall']:
if wall not in views:
cimage = ws.add_image()
cimage.add_feature(wall, effect=False, view = True)
else:
logging.warning('There are no walls around! Check your task!!!')
sys.exit(1)
# Ground predicates and actions
if not exp_signs:
ut._ground_predicates(problem.domain['predicates'], signs)
ut._ground_actions(problem.domain['actions'], obj_means, problem.constraints, signs, agents, agent_type)
else:
#TODO check if new action or predicate variation appeared in new task
for pred in problem.domain['predicates'].copy():
if pred in exp_signs:
signs[pred] = exp_signs[pred]
problem.domain['predicates'].pop(pred)
for act in problem.domain['actions'].copy():
if act in exp_signs:
signs[act] = exp_signs[act]
problem.domain['actions'].pop(act)
ut._ground_predicates(problem.domain['predicates'], signs)
ut._ground_actions(problem.domain['actions'], obj_means, problem.constraints, signs, agents, agent_type)
#Copy all experience subplans and plans
for sname, sign in exp_signs.items():
if sname not in signs:
signs[sname] = sign
# Define start situation
maps = {}
if backward:
maps[0] = problem.goal_state
else:
maps[0] = problem.initial_state
ms = maps[0].pop('map-size')
walls = maps[0].pop('wall')
static_map = {'map-size': ms, 'wall': walls}
# Create maps and situations for planning agents
regions_struct = ut.get_struct()
additions = []
additions.extend([maps, regions_struct, static_map])
cells = {}
agent_state = {}
for agent in agents:
region_map, cell_map_start, cell_location, near_loc, cell_coords, size, cl_lv_init = ut.signs_markup(init_state, static_map,
agent)
agent_state_start = ut.state_prediction(signs[agent], init_state, signs)
start_situation = ut.define_situation('*start-sit*-'+agent, cell_map_start, problem.initial_state['conditions'], agent_state_start, signs)
start_map = ut.define_map('*start-map*-'+agent, region_map, cell_location, near_loc, regions_struct, signs)
ut.state_fixation(start_situation, cell_coords, signs, 'cell')
# Define goal situation
region_map, cell_map_goal, cell_location, near_loc, cell_coords, size, cl_lv_goal = ut.signs_markup(go_state, static_map,
agent)
agent_state_finish = ut.state_prediction(signs[agent], go_state, signs)
goal_situation = ut.define_situation('*goal-sit*-'+agent, cell_map_goal, problem.goal_state['conditions'], agent_state_finish, signs)
goal_map = ut.define_map('*goal-map*-'+agent, region_map, cell_location, near_loc, regions_struct, signs)
ut.state_fixation(goal_situation, cell_coords, signs, 'cell')
#fixation map
map_size = ut.scale(ms)
rmap = [0, 0, map_size[0], map_size[1]]
region_location, _ = ut.locater('region-', rmap, initial_state['objects'], walls)
ut.state_fixation(start_map, region_location, signs, 'region')
ut.signify_connection(signs)
if agent == 'I':
additions[0][0][plagent]['cl_lv_init'] = cl_lv_init
additions[0][0][plagent]['cl_lv_goal'] = cl_lv_goal
else:
additions[0][0][agent]['cl_lv_init'] = cl_lv_init
additions[0][0][agent]['cl_lv_goal'] = cl_lv_goal
if backward:
cell_map_goal['cell-4'] = {plagent}
cells[agent] = {0:cell_map_goal}
else:
cell_map_start['cell-4'] = {plagent}
cells[agent] = {0: cell_map_start}
agent_state[agent] = {'start-sit':start_situation.sign, 'goal-sit': goal_situation.sign, 'start-map':start_map.sign,
'goal-map': goal_map.sign}
additions.insert(2, cells)
return SpTask(problem.name, signs, agent_state, additions, problem.initial_state,
{key:value for key, value in problem.goal_state.items() if key not in static_map}, static_map, plagent)
def ground(problem, plagent, exp_signs=None):
# ground I and They
domain = problem.domain
I_sign = Sign("I")
obj_means[I_sign] = I_sign.add_meaning()
obj_signifs[I_sign] = I_sign.add_significance()
signs[I_sign.name] = I_sign
They_sign = Sign("They")
obj_means[They_sign] = They_sign.add_meaning()
obj_signifs[They_sign] = They_sign.add_significance()
signs[They_sign.name] = They_sign
for type, stype in domain['types']:
stype_sign = __add_sign(stype)
stype_signif = stype_sign.add_significance()
type_sign = __add_sign(type)
connector = stype_signif.add_feature(obj_signifs[type_sign],
zero_out=True)
type_sign.add_out_significance(connector)
for obj, type in problem.objects:
obj_sign = __add_sign(obj)
obj_means[obj_sign] = obj_sign.add_meaning()
type_sign = signs[type]
tp_signif = type_sign.add_significance()
connector = tp_signif.add_feature(obj_signifs[obj_sign], zero_out=True)
obj_sign.add_out_significance(connector)
if obj_sign.name == plagent:
connector = obj_signifs[obj_sign].add_feature(obj_signifs[I_sign],
zero_out=True)
I_sign.add_out_significance(connector)
obj_means[obj_sign] = obj_sign.add_meaning()
others = set()
for id in range(1, len(signs['agent'].significances) + 1):
other_ag = signs['agent'].significances[id].get_signs()
if signs[plagent] not in other_ag:
others |= other_ag
for subagent in others:
if subagent.name != plagent:
if not They_sign in subagent.significances[1].get_signs():
signif = obj_signifs[They_sign]
if signif.is_empty():
They_signif = signif
else:
They_signif = They_sign.add_significance()
connector = subagent.significances[1].add_feature(
They_signif, zero_out=True)
They_sign.add_out_significance(connector)
obj_means[subagent] = subagent.add_meaning()
for predicate in domain['predicates']:
_ground_predicate(predicate.name, predicate.signature)
for action in domain['actions']:
_ground_action(action.name, action.parameters, action.preconditions,
action.effect, problem.constraints, plagent)
for task in domain['tasks']:
__add_sign(task.name, False)
methods = sorted(domain['methods'],
key=lambda method: len(method.subtasks))
for method in methods:
__ground_method(method.parameters, method.subtasks, method.ordering,
method.task, domain, 2)
# Ground Init
start = __add_sign('*start %s*' % str(problem.name), False)
sit_im = start.add_image()
for predicate in problem.init:
pred_im = _ground_htn_predicate(predicate.name, predicate.signature,
plagent)
connector = sit_im.add_feature(pred_im)
pred_im.sign.add_out_image(connector)
sit_im.copy('image', 'meaning')
# Ground htns to meanings
goal = None
subtasks = []
for htn in problem.htns:
htn_name = 'htn_' + str(problem.htns.index(htn))
htn_sign = __add_sign(htn_name, False)
htn_mean = htn_sign.add_meaning()
for task in htn.ordering:
subtask = htn.subtasks[task]
cm = __ground_htn_subtask(subtask[0], subtask[1], domain)
connector = htn_mean.add_feature(cm)
cm.sign.add_out_meaning(connector)
subtasks.append(htn_sign)
from mapmulti.grounding.pddl_grounding import signify_connection
signify_connection(signs)
return Task(problem.name, signs, start, goal, subtasks)
def _ground_predicates(predicates, signs):
# ground predicates
for predicate_name, signature in predicates.items():
variations = [pr for pr in signature if predicate_name in pr]
if not predicate_name in signs:
pred_sign = Sign(predicate_name)
signs[predicate_name] = pred_sign
else:
pred_sign = signs[predicate_name]
if 'cause' and 'effect' in signature:
pred_signif = pred_sign.add_significance()
if len(signature['cause']) > 1:
for part, iner in signature.items():
matrices = get_attributes(iner, signs)
for el in matrices:
if part == "cause":
connector = pred_signif.add_feature(el[1],
effect=False,
zero_out=True)
else:
connector = pred_signif.add_feature(el[1],
effect=True,
zero_out=True)
el[0].add_out_significance(connector)
elif variations:
for part, iner in signature.items():
mixed = []
matrices = []
pred_signif = pred_sign.add_significance()
for element in iner:
effect = True
if 'cause' in element: effect = False
if not 'any' in iner[element]:
matrices = get_attributes(iner[element], signs)
for el in matrices:
connector = pred_signif.add_feature(el[1],
effect=effect,
zero_out=True)
el[0].add_out_significance(connector)
else:
for key, el in iner[element].items():
matrices.extend(get_attributes(el, signs))
mixed.append(matrices)
matrices = []
if mixed:
combinations = itertools.product(mixed[0], mixed[1])
history = []
for element in combinations:
el_signs = element[0][0], element[1][0]
if not element[0][0] == element[1][
0] and el_signs not in history:
history.append(el_signs)
history.append((el_signs[1], el_signs[0]))
pred_signif = pred_sign.add_significance()
connector = pred_signif.add_feature(element[0][1],
effect=False)
element[0][0].add_out_significance(connector)
connector = pred_signif.add_feature(element[1][1],
effect=True)
element[1][0].add_out_significance(connector)
def define_map(map_name, region_map, cell_location, near_loc, regions_struct,
signs):
signs[map_name] = Sign(map_name)
map_image = signs[map_name].add_image()
elements = {}
contain_sign = signs['contain']
region_sign = signs['region']
few_sign = signs['few']
noth_sign = signs['nothing']
location_signif = \
[matr for _, matr in signs['location'].significances.items() if signs['direction'] in matr.get_signs()][0]
contain_reg = [
region for region, cells in cell_location.items() if 'cell-4' in cells
][0]
def get_or_add(sign):
if sign not in elements:
image = sign.add_image()
elements[sign] = image
return elements.get(sign)
for region, objects in region_map.items():
region_x = signs[region]
flag = False
if 0 in objects:
flag = True
objects.remove(0)
objects.add("nothing")
cont_signif = [
signif for _, signif in contain_sign.significances.items()
if signs['region'] in signif.get_signs()
and noth_sign in signif.get_signs()
][0]
else:
cont_signif = [
signif for _, signif in contain_sign.significances.items()
if signs['region'] in signif.get_signs()
and signs['object'] in signif.get_signs()
][0]
connectors = []
for object in objects:
if object in signs:
ob_sign = signs[object]
else:
ob_sign = Sign(object)
signs[object] = ob_sign
for s_name, sign in signs.items():
if s_name in object and s_name != object:
obj_signif = ob_sign.add_significance()
tp_signif = sign.add_significance()
connector = tp_signif.add_feature(obj_signif,
zero_out=True)
ob_sign.add_out_significance(connector)
break
ob_image = get_or_add(ob_sign)
pm = cont_signif.copy('significance', 'image')
region_image = region_x.add_image()
pm.replace('image', region_sign, region_image)
pm.replace('image', signs['object'], ob_image)
if not flag:
few_image = few_sign.add_image()
pm.replace('image', signs['amount'], few_image)
if connectors:
con = connectors[0]
connector = map_image.add_feature(pm, con.in_order)
else:
connector = map_image.add_feature(pm)
contain_sign.add_out_image(connector)
if not connectors:
connectors.append(connector)
loc_sign = get_reg_location(cell_location, near_loc, region, signs)
connector = connectors[0]
am = None
for id, signif in loc_sign.significances.items():
if resonated(signif, regions_struct, region, contain_reg, signs):
am = signif.copy('significance', 'image')
break
if not am:
print('Did not find applicable map')
sys.exit(1)
cell_image = signs["cell-4"].add_image()
am.replace('image', signs["cell?x"], cell_image)
inner_matrices = am.spread_down_activity('image', 3)
for lmatrice in inner_matrices:
if lmatrice[-1].sign.name == "region?z":
reg_image = signs[region].add_image()
am.replace('image', signs["region?z"], reg_image)
break
else:
for lmatrice in inner_matrices:
if lmatrice[-1].sign.name == "region?y":
reg_image = signs[region].add_image()
am.replace('image', signs["region?y"], reg_image)
reg_image = signs[contain_reg].add_image()
am.replace('image', signs["region?x"], reg_image)
# direction matrice
if contain_reg != region:
dir_sign = signs[regions_struct[contain_reg][region][1]]
else:
dir_sign = signs["inside"]
dir_matr = dir_sign.add_image()
# location matrice
location_am = location_signif.copy('significance', 'image')
location_am.replace('image', signs['distance'], am)
location_am.replace('image', signs['direction'], dir_matr)
con = map_image.add_feature(location_am, connector.in_order)
loc_sign.add_out_image(con)
return map_image
def save_plan(self, start, finish, actions, plan_name, subplans=None):
# Creating plan action for further use
if not plan_name:
plan_name = 'plan_' + self.name
if not start.sign.meanings:
scm = start.copy('image', 'meaning')
start.sign.add_meaning(scm)
if not finish.sign.meanings:
fcm = finish.copy('image', 'meaning')
finish.sign.add_meaning(fcm)
plan_sign = Sign(plan_name)
plan_mean = plan_sign.add_meaning()
connector = plan_mean.add_feature(start.sign.meanings[1])
start.sign.add_out_meaning(connector)
conn = plan_mean.add_feature(finish.sign.meanings[1], effect=True)
finish.sign.add_out_meaning(conn)
self.signs[plan_sign.name] = plan_sign
# Adding Sequence of actions to plan image
plan_image = plan_sign.add_image()
iter = -1
if not subplans:
for act in actions:
im = act[2].sign.add_image()
connector = plan_image.add_feature(im)
act[2].sign.add_out_image(
connector
) # add connector to plan_sign threw images to out_image
else:
# ots = {subplans.index(it): range(it[1], it[2]+1) for it in subplans}
# for act in actions:
# iter += 1
# flag = False
# for index, value in ots.items():
# if iter == value[0]:
# if subplans[index][0].images:
# im = subplans[index][0].images[1]
# else:
# im = subplans[index][0].add_image()
# connector = plan_image.add_feature(im)
# subplans[index][0].add_out_image(connector)
# flag = True
# break
# elif iter in value:
# flag = True
# break
# if flag:
# continue
# else:
# im = act[2].sign.add_image()
# connector = plan_image.add_feature(im)
# act[2].sign.add_out_image(connector)
for sub in subplans:
if sub[2].sign.images:
connector = plan_image.add_feature(sub[2].sign.images[1])
else:
they_im = sub[2].sign.add_image()
connector = plan_image.add_feature(they_im)
sub[2].sign.add_out_image(
connector
) # add connector to plan_sign threw images to out_image
# Adding scenario vs partly concrete actions to the plan sign
scenario = self.scenario_builder(start, finish, actions)
plan_signif = plan_sign.add_significance()
for act in scenario:
connector = plan_signif.add_feature(act)
act.sign.add_out_significance(connector)
return [plan_sign, start.sign, finish.sign]
def ground(problem, plagent, exp_signs=None):
domain = problem.domain
actions = domain.actions.values()
predicates = domain.predicates.values()
constraints = problem.constraints
# Objects
objects = problem.objects
objects.update(domain.constants)
logging.debug('Objects:\n%s' % objects)
# Remove old type_map
if exp_signs:
objects = _update_exp_signs(exp_signs, objects)
# Create a map from types to objects
type_map = _create_type_map(objects)
logging.debug("Type to object map:\n%s" % type_map)
# Create type subtype map
subtype_map = _create_subtype(domain.types)
obj_signifs = {}
# add agents, because on significances they have a inner link to I and They signs
obj_means = {}
# Check logic in exp
if exp_signs:
signs = exp_signs
I_sign = signs['I']
They_sign = signs['They']
obj_means[I_sign] = I_sign.meanings[1]
obj_signifs[I_sign] = I_sign.significances[1]
obj_means[They_sign] = They_sign.meanings[1]
obj_signifs[They_sign] = They_sign.significances[1]
signs['situation'] = exp_signs['situation']
else:
signs = {}
I_sign = Sign("I")
obj_means[I_sign] = I_sign.add_meaning()
obj_signifs[I_sign] = I_sign.add_significance()
signs[I_sign.name] = I_sign
They_sign = Sign("They")
obj_means[They_sign] = They_sign.add_meaning()
obj_signifs[They_sign] = They_sign.add_significance()
signs[They_sign.name] = They_sign
signs['situation'] = Sign('situation')
for obj in objects:
obj_sign = Sign(obj)
obj_signifs[obj_sign] = obj_sign.add_significance()
signs[obj] = obj_sign
if obj_sign.name == plagent:
connector = obj_signifs[obj_sign].add_feature(obj_signifs[I_sign],
zero_out=True)
I_sign.add_out_significance(connector)
obj_means[obj_sign] = obj_sign.add_meaning()
for tp, objects in type_map.items():
if exp_signs:
tp_sign = signs[tp.name]
else:
tp_sign = Sign(tp.name)
for obj in objects:
obj_signif = obj_signifs[signs[obj]]
tp_signif = tp_sign.add_significance()
connector = tp_signif.add_feature(obj_signif, zero_out=True)
signs[obj].add_out_significance(connector)
if not exp_signs:
signs[tp.name] = tp_sign
others = set()
for id in range(1, len(signs['agent'].significances) + 1):
other_ag = signs['agent'].significances[id].get_signs()
if signs[plagent] not in other_ag:
others |= other_ag
for subagent in others:
if subagent.name != plagent:
if not They_sign in subagent.significances[1].get_signs():
signif = obj_signifs[They_sign]
if signif.is_empty():
They_signif = signif
else:
They_signif = They_sign.add_significance()
connector = subagent.significances[1].add_feature(
They_signif, zero_out=True)
They_sign.add_out_significance(connector)
obj_means[subagent] = subagent.add_meaning()
if not exp_signs:
updated_predicates = _update_predicates(predicates, actions)
signify_predicates(predicates, updated_predicates, signs, subtype_map,
domain.constants)
signify_actions(actions, constraints, signs, plagent, obj_means,
obj_signifs)
signify_connection(signs)
start_situation, pms = _define_situation('*start*', problem.initial_state,
signs, 'image')
goal_situation, pms = _define_situation('*finish*', problem.goal, signs,
'image')
# if problem.name.startswith("blocks"):
# list_signs = task_signs(problem)
# _expand_situation_ma_blocks(goal_situation, signs, pms, list_signs) # For task
return MaPlanningTask(problem.name, signs, start_situation, goal_situation)
def create_script_sign(list_files,
name_table=None,
key_word="sem_rel",
script_name="Script"):
"""
This function creates Script and the required signs for it and
for the actions, roles and their possible placeholders (objects).
The adding of connectors in Script is implemented in function add_significance
This function returns the Sign of Script (S),
the signs of actions (dict 'actions_sign'),
the role signs (dict 'role_sign'),
the placeholders signs (dict 'obj_sign'),
characteristics signs (dict 'char_sign')
significances (dict 'signifs')
"""
if name_table is None:
name_table = "DELETE.pickle"
# Extract semantic relations and syntactic dependences for all texts in list_files
# into table
graph_script = get_srcipt(list_files, name_table)
V_descr = graph_script.V_descr
# The script sign
S = Sign(script_name)
# The keys of the following dictionaries are signs name. The value is sign
actions_sign = {}
role_sign = {}
obj_sign = {}
char_sign = {}
signifs = {}
signifs[script_name] = S.add_significance()
order = None
for v in graph_script.V:
connector_script = add_signifs(V_descr[v],
S=S,
signifs=signifs,
script_name=script_name,
actions_sign=actions_sign,
role_sign=role_sign,
obj_sign=obj_sign,
char_sign=char_sign,
order=order)
obj_sign_names = list(obj_sign.keys())
parser = Parser()
hyperonyms_key = "Гиперонимы"
hyponyms_key = "Гипонимы"
synonyms_key = "Синонимы"
for obj_name in obj_sign_names:
response = parser.get_word_info(obj_name)
hyperonyms = response[hyperonyms_key]
if hyperonyms is None:
hyperonyms = []
for word in hyperonyms:
add_obj_link(obj_name,
word,
link="hyper",
obj_sign=obj_sign,
signifs=signifs)
hyponyms = response[hyponyms_key]
if hyponyms is None:
hyponyms = []
for word in hyponyms:
add_obj_link(obj_name,
word,
link="hypo",
obj_sign=obj_sign,
signifs=signifs)
#synonyms = response[synonyms_key]
#if synonyms is None:
# synonyms = []
#for word in synonyms:
# add_obj_link(obj_name, word, link = "syno", obj_sign = obj_sign, signifs = signifs)
return S, actions_sign, role_sign, obj_sign, char_sign, signifs
def signify_predicates(predicates,
updated_predicates,
signs,
subtype_map,
constants=None):
for predicate in predicates:
pred_sign = Sign(predicate.name)
signs[predicate.name] = pred_sign
def update_single(facts):
for fact in facts:
role_name = fact[1][0].name + fact[0]
fact_name = fact[1][0].name
if role_name not in signs:
role_sign = Sign(role_name)
signs[role_name] = role_sign
else:
role_sign = signs[role_name]
if fact_name not in signs:
fact_sign = Sign(fact_name)
signs[fact_name] = fact_sign
else:
fact_sign = signs[fact_name]
role_signif = role_sign.add_significance()
fact_signif = fact_sign.add_significance()
connector = role_signif.add_feature(fact_signif, zero_out=True)
fact_sign.add_out_significance(connector)
def update_significance(fact,
predicate,
subtype_map,
updated_predicates,
index,
effect=False,
constants=None):
def add_sign(updated_fact, ufn, ufr):
if isinstance(updated_fact[0], tuple):
used_facts.add(updated_fact[0][1:])
else:
used_facts.add(ufn)
if ufr not in signs:
signs[ufr] = Sign(ufr)
if not ufr in roles:
roles.append(ufr)
role_name = fact[1][0].name + fact[0]
fact_name = fact[1][0].name
roles = []
roles.append(role_name)
role_signifs = []
subroles = []
if role_name not in signs:
signs[role_name] = Sign(role_name)
if fact_name in subtype_map.keys():
subroles = subtype_map[fact_name]
for role, signif in subtype_map.items():
if fact_name in signif:
for srole in subroles:
srole_name = role + "?" + srole
signs[srole_name] = Sign(srole_name)
if not srole_name in roles:
roles.append(srole_name)
sfact_name = fact_name + "?" + srole
signs[sfact_name] = Sign(sfact_name)
if not sfact_name in roles:
roles.append(sfact_name)
used_facts = set()
for updated_fact in updated_predicates[pred_sign.name]:
ufn = updated_fact[1][0].name
if not updated_fact[0].startswith('?'):
new_fact = '?' + updated_fact[0]
else:
new_fact = updated_fact[0]
ufr = updated_fact[1][0].name + new_fact
if updated_fact[0] in constants:
ufr_sign = Sign(ufr)
signs[ufr] = ufr_sign
role_signif = ufr_sign.add_significance()
obj_sign = signs[updated_fact[0]]
conn = role_signif.add_feature(obj_sign.significances[1],
zero_out=True)
obj_sign.add_out_significance(conn)
role_signifs.append(role_signif)
else:
predicate_names = [
signa[1][0].name for signa in predicate.signature
]
if fact_name == ufn:
add_sign(updated_fact, ufn, ufr)
elif fact[0] == updated_fact[0]:
add_sign(updated_fact, ufn, ufr)
elif ufn in subtype_map[
fact_name] and not ufn in predicate_names:
add_sign(updated_fact, ufn, ufr)
for role_name in roles:
role_sign = signs[role_name]
obj_sign = signs[fact_name]
spec_sign = None
if obj_sign.name in role_sign.name:
spec_sign = role_sign.name[len(obj_sign.name) + 1:]
smaller_roles = []
if spec_sign and subroles:
for srole in subroles:
if spec_sign in srole:
smaller_roles.append(srole)
if not smaller_roles and spec_sign:
smaller_roles = [
obj for obj in used_facts
if spec_sign in obj and obj in signs
]
if smaller_roles:
for obj in smaller_roles:
updated_obj_sign = signs[obj]
if not obj_sign == updated_obj_sign:
role_signif = role_sign.add_significance()
connector = role_signif.add_feature(
updated_obj_sign.significances[1],
zero_out=True)
updated_obj_sign.add_out_significance(connector)
role_signifs.append(role_signif)
else:
role_signif = role_sign.add_significance()
conn = role_signif.add_feature(
obj_sign.significances[1], zero_out=True)
obj_sign.add_out_significance(conn)
role_signifs.append(role_signif)
else:
role_signif = role_sign.add_significance()
conn = role_signif.add_feature(obj_sign.significances[1],
zero_out=True)
obj_sign.add_out_significance(conn)
role_signifs.append(role_signif)
# signa - variations
if index < len(predicate.signature) - 1:
signifs[index] = role_signifs
else:
signifs[index] = role_signifs
if not constants:
for elems in itertools.product(*signifs.values()):
pred_signif = pred_sign.add_significance()
for elem in elems:
conn = pred_signif.add_feature(elem, zero_out=True)
elem.sign.add_out_significance(conn)
else:
pred_signif = pred_sign.add_significance()
for signa in predicate.signature:
for element in signifs:
if signa[1][0].name in element.sign.name:
conn = pred_signif.add_feature(element,
zero_out=True)
element.sign.add_out_significance(conn)
break
# predicate with solo signa or without signa simular to role
if len(predicate.signature) >= 2:
signifs = {}
for index in range(len(predicate.signature)):
update_significance(predicate.signature[index],
predicate,
subtype_map,
updated_predicates,
index,
constants=constants)
else:
update_single(updated_predicates[predicate.name])
pred_sign.add_significance()
def ground(problem, agent, exp_signs=None):
domain = problem.domain
actions = domain.actions.values()
predicates = domain.predicates.values()
# Objects
objects = problem.objects
objects.update(domain.constants)
logging.debug('Objects:\n%s' % objects)
# Remove old type_map
if exp_signs:
objects = _update_exp_signs(exp_signs, objects)
# Create a map from types to objects
type_map = _create_type_map(objects)
logging.debug("Type to object map:\n%s" % type_map)
# Create type subtype map
subtype_map = _create_subtype(domain.types)
obj_signifs = {}
obj_means = {}
# Check logic in exp
if exp_signs:
signs = exp_signs
I_sign = signs['I']
obj_means[I_sign] = I_sign.meanings[1]
obj_signifs[I_sign] = I_sign.significances[1]
else:
signs = {}
I_sign = Sign("I")
obj_means[I_sign] = I_sign.add_meaning()
obj_signifs[I_sign] = I_sign.add_significance()
signs[I_sign.name] = I_sign
signs['situation'] = Sign('situation')
for obj in objects:
obj_sign = Sign(obj)
obj_signifs[obj] = obj_sign.add_significance()
signs[obj] = obj_sign
if obj_sign.name == agent:
connector = obj_signifs[obj].add_feature(obj_signifs[I_sign],
zero_out=True)
I_sign.add_out_significance(connector)
for tp, objects in type_map.items():
if exp_signs:
tp_sign = signs[tp.name]
else:
tp_sign = Sign(tp.name)
for obj in objects:
obj_signif = obj_signifs[obj]
tp_signif = tp_sign.add_significance()
connector = tp_signif.add_feature(obj_signif, zero_out=True)
signs[obj].add_out_significance(connector)
if not exp_signs:
signs[tp.name] = tp_sign
if not exp_signs:
updated_predicates = _update_predicates(predicates, actions)
signify_predicates(predicates, updated_predicates, signs, subtype_map,
domain.constants)
agent_roles = {}
pred_names = {pred.name for pred in predicates}
if agent:
agent_role_cms = signs[agent].spread_up_activity_obj(
'significance', 3)
roles = {
cm.sign
for cm in agent_role_cms if cm.sign.name not in pred_names
}
agent_roles[signs[agent]] = roles
signify_actions(actions, signs, obj_means, agent_roles)
start_situation, pms = _define_situation('*start*', problem.initial_state,
signs, 'image')
goal_situation, pms = _define_situation('*finish*', problem.goal, signs,
'image')
return Task(problem.name, signs, start_situation, goal_situation)
def signify_actions(actions, signs, obj_means, agent_roles):
for action in actions:
act_sign = Sign(action.name)
act_signif = act_sign.add_significance()
def update_significance(predicate, signature, effect=False):
pred_sign = signs[predicate.name]
if len(pred_sign.significances) > 1:
pred_cm = pred_resonate('significance', pred_sign, predicate,
signs, signature)
if not pred_cm:
raise Exception(
'Cant find *{0}* matrice in *{1}* action'.format(
predicate.name, action.name))
elif len(pred_sign.significances) == 0:
pred_cm = pred_sign.add_significance()
else:
pred_cm = pred_sign.significances[1]
connector = act_signif.add_feature(pred_cm, effect=effect)
pred_sign.add_out_significance(connector)
if len(predicate.signature) == 1:
signa = predicate.signature[0]
if not signa[0].startswith('?'):
new_fact = '?' + signa[0]
else:
new_fact = signa[0]
role_sign = signs[signa[1][0].name + new_fact]
conn = act_signif.add_feature(role_sign.significances[1],
connector.in_order,
effect=effect,
zero_out=True)
role_sign.add_out_significance(conn)
elif not len(predicate.signature) == 0:
if not predicate.signature[0][1][
0].name == predicate.signature[1][1][0].name:
for role_sign in pred_cm.get_signs():
connector_new = act_signif.add_feature(
role_sign.significances[1],
connector.in_order,
effect=effect,
zero_out=True)
role_sign.add_out_significance(connector_new)
for predicate in action.precondition:
update_significance(predicate, action.signature, False)
for predicate in action.effect.addlist:
update_significance(predicate, action.signature, True)
signs[action.name] = act_sign
act_meaning = act_signif.copy('significance', 'meaning')
I_sign = signs['I']
connector = act_meaning.add_feature(obj_means[I_sign])
efconnector = act_meaning.add_feature(obj_means[I_sign], effect=True)
I_sign.add_out_meaning(connector)
for agent, roles in agent_roles.items():
I_obj_mean = agent.add_meaning()
mean_signs = set()
act_mean = act_meaning.spread_down_activity('meaning', 3)
for pm_list in act_mean:
mean_signs |= set([c.sign for c in pm_list])
role_signs = roles & mean_signs
for rs in role_signs:
act_meaning.replace('meaning', rs, I_obj_mean)
def ground(problem, plagent, exp_signs=None):
domain = problem.domain
# ground I and They
I_sign = Sign("I")
obj_means[I_sign] = I_sign.add_meaning()
obj_signifs[I_sign] = I_sign.add_significance()
signs[I_sign.name] = I_sign
They_sign = Sign("They")
obj_means[They_sign] = They_sign.add_meaning()
obj_signifs[They_sign] = They_sign.add_significance()
signs[They_sign.name] = They_sign
situation = Sign('situation')
signs['situation'] = situation
for type, stype in domain['types']:
stype_sign = __add_sign(stype)
stype_signif = stype_sign.add_significance()
type_sign = __add_sign(type)
connector = stype_signif.add_feature(obj_signifs[type_sign],
zero_out=True)
type_sign.add_out_significance(connector)
for obj, type in problem.objects:
obj_sign = __add_sign(obj)
obj_means[obj_sign] = obj_sign.add_meaning()
type_sign = signs[type]
tp_signif = type_sign.add_significance()
connector = tp_signif.add_feature(obj_signifs[obj_sign], zero_out=True)
obj_sign.add_out_significance(connector)
if obj_sign.name == plagent:
connector = obj_signifs[obj_sign].add_feature(obj_signifs[I_sign],
zero_out=True)
I_sign.add_out_significance(connector)
obj_means[obj_sign] = obj_sign.add_meaning()
for predicate in domain['predicates']:
_ground_predicate(predicate.name, predicate.signature)
for action in domain['actions']:
_ground_action(action.name,
action.parameters,
action.preconditions,
action.effect,
plagent=plagent)
for task in domain['tasks']:
__add_sign(task.name, False)
methods = sorted(domain['methods'],
key=lambda method: len(method.subtasks))
for method in methods:
__ground_method(method.parameters, method.subtasks, method.ordering,
method.task, domain, 2)
#Ground Init
start = __add_sign('*start %s*' % str(problem.name), False)
sit_im = start.add_image()
for predicate in problem.init:
pred_im = _ground_htn_predicate(predicate.name, predicate.signature,
plagent)
connector = sit_im.add_feature(pred_im)
pred_im.sign.add_out_image(connector)
sit_im.copy('image', 'meaning')
global_cm = situation.add_image()
connector = global_cm.add_feature(sit_im)
getattr(start, 'add_out_image')(connector)
#Ground htns to meanings
goal = None
subtasks = []
for htn in problem.htns:
htn_name = 'htn_' + str(problem.htns.index(htn))
htn_sign = __add_sign(htn_name, False)
htn_mean = htn_sign.add_meaning()
for task in htn.ordering:
subtask = htn.subtasks[task]
cm = __ground_htn_subtask(subtask[0], subtask[1], problem)
connector = htn_mean.add_feature(cm)
cm.sign.add_out_meaning(connector)
subtasks.append(htn_sign)
return Task(problem.name, signs, start, goal, subtasks)