def UserGoalsMidca(domainFile,
stateFile,
display=print,
goalsFile=None,
argsPyHopPlanner=[]):
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display=display, verbose=4)
#add phases by name
for phase in [
"Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan",
"Act"
]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner(*argsPyHopPlanner))
myMidca.append_module("Act", act.SimpleAct())
return myMidca
def UserGoalsMidca(domainFile, stateFile, goalsFile = None, extinguish = False):
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
myMidca = base.PhaseManager(world, verbose=1, display = asqiiDisplay, metaEnabled=True)
# add cognitive layer phases
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
# add cognitive layer modules
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planningbroken.PyHopPlannerBroken(extinguish))
myMidca.append_module("Act", act.SimpleAct())
# add meta layer phases
#for phase in ["Monitor", "Interpret", "Eval", "Intend", "Plan", "Control"]:
for phase in ["Monitor", "Interpret", "Intend", "Plan", "Control"]:
myMidca.append_meta_phase(phase)
# add meta layer modules
myMidca.append_meta_module("Monitor", monitor.MRSimpleMonitor())
myMidca.append_meta_module("Interpret", interpret.MRSimpleDetect())
myMidca.append_meta_module("Interpret", interpret.MRSimpleGoalGen())
myMidca.append_meta_module("Intend", metaintend.MRSimpleIntend())
myMidca.append_meta_module("Plan", plan.MRSimplePlanner())
myMidca.append_meta_module("Control", control.MRSimpleControl())
return myMidca
def save_30_buildings(self):
'''
save the 30 building goals into the 30_problem_set_ijcai.pickle file
'''
a = {}
for k in range(0, 30):
self.curr_goal_sets[:] = []
select_buildings = 0
index = []
objs_names = self.world.get_objects_names_by_type("BLOCK")
# remove the object table since we need only blocks
objs_names.remove("table")
random.shuffle(objs_names)
# builds the gaol sets
#self.build_current_goal_sets(objs_names)
self.build_current_goal_sets_same(objs_names)
atoms = self.world.get_atoms()
self.remove_bunch_atoms(atoms)
stateread.apply_state_file(self.world, self.stateFile)
stateread.apply_state_str(self.world, self.state_str)
self.mem.add(self.mem.STATES, copy.deepcopy(self.world))
self.mem.set(self.mem.TIME_CONSTRUCTION, self.Time)
#print(self.world)
# empty the selected goals list
del self.selected_goals[:]
# generate some random goals through random function on current goal set
# this random function is for no:of buildings
select_buildings = random.randint(2, len(self.curr_goal_sets) - 1)
print(("NO.OF BUILDINGS TO CONSTRUCT: " + str(select_buildings)))
# this is for the random indexes , that should be taken from the variable self.curr_goal_sets
# compute the index list with in the range of 0 and no:of buildings
index = random.sample(list(range(0, len(self.curr_goal_sets))),
select_buildings)
print("THE BUILDINGS ARE: ")
print("[")
for i in index:
# since self.curr_goal_sets is in a structure of list in a list
# we should iterate through the list completely
print(("Tower " + self.curr_goal_sets[i][0].args[0]), end=' ')
if (len(self.curr_goal_sets[i]) == 1):
print(("(" + str(len(self.curr_goal_sets[i])) + " Block)"))
else:
print(
("(" + str(len(self.curr_goal_sets[i])) + " Blocks)"))
for j in self.curr_goal_sets[i]:
#print(j)
self.selected_goals.append(j)
#print("")
print("]")
print("")
random.shuffle(index)
print(index)
a[k] = [
self.curr_goal_sets, select_buildings,
copy.deepcopy(index)
]
with open('30_problem_set_ijcai.pickle', 'wb') as handle:
pickle.dump(a, handle)
def guiMidca(domainFile, stateFile, goalsFile = None):
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
myMidca = base.PhaseManager(world, display = asqiiDisplay)
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner())
myMidca.append_module("Act", act.SimpleAct())
return myMidca
def guiMidca(domainFile, stateFile, goalsFile = None):
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
myMidca = base.PhaseManager(world, display = asqiiDisplay)
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner())
myMidca.append_module("Act", act.SimpleAct())
return myMidca
def UserGoalsMidca(domainFile, stateFile, display=print, goalsFile = None, argsPyHopPlanner=[]):
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display = display, verbose=4)
#add phases by name
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner(*argsPyHopPlanner))
myMidca.append_module("Act", act.SimpleAct())
return myMidca
def next_goal(self):
# empty the previous goals and set the money to default in memory
self.mem.set(self.mem.MONEY, self.money)
# remove all the atoms in the world
atoms = self.world.get_atoms()
self.remove_bunch_atoms(atoms)
# whenever we get a new goal, first initialize the world to it's default state
stateread.apply_state_file(self.world, self.stateFile)
stateread.apply_state_str(self.world, self.state_str)
self.mem.add(self.mem.STATES, copy.deepcopy(self.world))
# Create the random set of goals with random dishes and persons
self.curr_goal_sets[:] = []
self.create_random_goals()
#self.save_30_goal_sets()
#self.write_memory_to_file()
#self.select_random_goals_from_30_sets()
# print the generated goals
print("")
for each_goal in self.curr_goal_sets:
print(each_goal)
print("")
# return the generated goals
return self.curr_goal_sets
thisDir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
MIDCA_ROOT = thisDir + "/../"
domainFile = MIDCA_ROOT + "domains/blocksworld/arsonist_extinguish.sim"
stateFile = MIDCA_ROOT + "domains/blocksworld/states/extinguisher_state.sim"
extinguish = True
argsPyHopPlanner = [util.pyhop_state_from_world,
util.pyhop_tasks_from_goals,
DECLARE_METHODS_FUNC,
DECLARE_OPERATORS_FUNC,
extinguish]
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display = util.asqiiDisplay, verbose=4)
#add phases by name
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", PerfectObserver.PerfectObserver())
myMidca.append_module("Interpret", ADistanceAnomalyNoter.ADistanceAnomalyNoter())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", SimpleEval.SimpleEval())
myMidca.append_module("Intend", SimpleIntend.SimpleIntend())
myMidca.append_module("Plan", PyHopPlanner.PyHopPlanner(*argsPyHopPlanner))
# return "incomplete"
# if there is no state do not send report to meta aqua
if not self.finalstate:
return "incomplete"
else:
self.namecounts["report"] += 1
s = "(" + "report." + str(self.namecounts["report"]) + "\n("
for action in self.actions:
s += "\t(\n"
s += self.action_str(action)
s += "\n\"\")\n("
s += self.state_str(self.finalstate)
s += "\n\"\")\n"
return s + "))"
'''
ma = MAReport()
import domainread, stateread
world = domainread.load_domain("./domain.sim")
stateread.apply_state_file(world, "./defstate.sim")
ma.finalstate = world
ma.actions.append(["unstack", "block1", "block2"])
ma.actions.append(["catchfire", "block1"])
print ma
'''
class MAReporter(base.BaseModule):
'''
MIDCA module that sends a report on the world and actions to the
Meta-AQUA story understanding system. This requires Meta-AQUA to be
def next_goal(self, write_to_file=False):
actual_time = self.mem.get(self.mem.ACTUAL_TIME_CONSTRUCTION)
expected_time = self.mem.get(self.mem.EXPECTED_TIME_CONSTRUCTION)
selected_buildings = self.mem.get(self.mem.SELECTED_BUILDING_LIST)
complete_buildings = self.mem.get(self.mem.COMPLETE_BUILDING_LIST)
executed_buildings = self.mem.get(self.mem.EXECUTED_BUILDING_LIST)
actual_scores = self.mem.get(self.mem.ACTUAL_SCORES)
if executed_buildings:
expected_scores = sum(executed_buildings)
else:
expected_scores = 0
if actual_time and expected_time:
expected_p_t = float(expected_scores / expected_time[0])
actual_p_t = float(actual_scores / actual_time[0])
if write_to_file:
with open("evaluation.txt", "a") as myfile:
myfile.write(
"%-5s %-5s %-5s %-5s " %
(str(complete_buildings), str(selected_buildings),
str(expected_time), str(actual_time)))
myfile.write("%-5s %-5s %-5s %-5s %-5s " %
(str([expected_scores]), str([actual_scores]),
str([expected_p_t]), str(
[actual_p_t]), str(executed_buildings)))
myfile.write("\n")
self.mem.set(self.mem.ACTUAL_TIME_CONSTRUCTION, None)
self.mem.set(self.mem.EXPECTED_TIME_CONSTRUCTION, None)
self.mem.set(self.mem.SELECTED_BUILDING_LIST, None)
self.mem.set(self.mem.COMPLETE_BUILDING_LIST, None)
self.mem.set(self.mem.EXECUTED_BUILDING_LIST, None)
self.mem.set(self.mem.ACTUAL_SCORES, None)
#print(self.mem.get(self.mem.STATES)[-1])
#print(self.initial_world)
# initiate the world
#predicateworld.asqiiDisplay(world)
#self.world = self.initial_world.copy()
#print("Modified world")
#print(self.world)
#base.MIDCA.update_world(self,self.initial_world.copy())
#self.mem.add(self.mem.STATES, self.initial_world.copy())
#print(self.mem.get(self.mem.STATES)[-1]
#atoms = self.initial_world.get_atoms()
#atoms1 = self.initial_world.get_atoms()
#for atom in atoms1:
# self.world.add_atom(atom)
# get all the object names of type block
self.curr_goal_sets[:] = []
objs_names = self.world.get_objects_names_by_type("BLOCK")
# remove the object table since we need only blocks
objs_names.remove("table")
random.shuffle(objs_names)
# builds the gaol sets
#self.build_current_goal_sets(objs_names)
self.build_current_goal_sets_same(objs_names)
atoms = self.world.get_atoms()
self.remove_bunch_atoms(atoms)
stateread.apply_state_file(self.world, self.stateFile)
stateread.apply_state_str(self.world, self.state_str)
self.mem.add(self.mem.STATES, copy.deepcopy(self.world))
self.mem.set(self.mem.TIME_CONSTRUCTION, self.Time)
#print(self.world)
# empty the selected goals list
del self.selected_goals[:]
# generate some random goals through random function on current goal set
# this random function is for no:of buildings
select_buildings = random.randint(2, len(self.curr_goal_sets) - 1)
print(("NO.OF BUILDINGS TO CONSTRUCT: " + str(select_buildings)))
# this is for the random indexes , that should be taken from the variable self.curr_goal_sets
# compute the index list with in the range of 0 and no:of buildings
index = random.sample(list(range(0, len(self.curr_goal_sets))),
select_buildings)
print("THE BUILDINGS ARE: ")
print("[")
for i in index:
# since self.curr_goal_sets is in a structure of list in a list
# we should iterate through the list completely
print(("Tower " + self.curr_goal_sets[i][0].args[0]), end=' ')
if (len(self.curr_goal_sets[i]) == 1):
print(("(" + str(len(self.curr_goal_sets[i])) + " Block)"))
else:
print(("(" + str(len(self.curr_goal_sets[i])) + " Blocks)"))
for j in self.curr_goal_sets[i]:
#print(j)
self.selected_goals.append(j)
print("]")
print("")
return self.selected_goals
def next_goal_30_goal_transformations(self, write_to_file=False):
selected_buildings = self.mem.get(self.mem.SELECTED_BUILDING_LIST)
executed_buildings = self.mem.get(self.mem.EXECUTED_BUILDING_LIST)
actual_scores = self.mem.get(self.mem.ACTUAL_SCORES)
if executed_buildings:
myfile = open('evaluation.csv', "a")
writer = csv.writer(myfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
with open("evaluation.csv", "a") as myfile:
data = [(self.count), selected_buildings, actual_scores,
executed_buildings]
writer.writerow(data)
self.mem.set(self.mem.SELECTED_BUILDING_LIST, None)
self.mem.set(self.mem.EXECUTED_BUILDING_LIST, None)
self.mem.set(self.mem.ACTUAL_SCORES, None)
else:
myfile = open('evaluation.csv', "a")
writer = csv.writer(myfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
data = [
"S.NO", "PROBLEM SET", "ACTUAL SCORES", "CONSTRUCTED BUILDINGS"
]
writer.writerow(data)
self.curr_goal_sets[:] = []
objs_names = self.world.get_objects_names_by_type("BLOCK")
# remove the object table since we need only blocks
objs_names.remove("table")
random.shuffle(objs_names)
# builds the gaol sets
self.build_current_goal_sets(objs_names)
atoms = self.world.get_atoms()
self.remove_bunch_atoms(atoms)
stateread.apply_state_file(self.world, self.stateFile)
stateread.apply_state_str(self.world, self.state_str)
self.mem.add(self.mem.STATES, copy.deepcopy(self.world))
self.mem.set(self.mem.TIME_CONSTRUCTION, self.Time)
print((self.world))
# empty the selected goals list
del self.selected_goals[:]
with open('30_problem_set.pickle', 'rb') as handle:
a = pickle.load(handle)
b = a[self.count]
self.count = self.count + 1
select_buildings = b[1]
print(("NO.OF BUILDINGS TO CONSTRUCT: " + str(select_buildings)))
# this is for the random indexes , that should be taken from the variable self.curr_goal_sets
# compute the index list with in the range of 0 and no:of buildings
index = b[2]
self.curr_goal_sets = b[0]
for each in self.curr_goal_sets:
for goal in each:
if goal["predicate"] == "on":
goal["predicate"] = "stable-on"
print("THE BUILDINGS ARE: ")
print("[")
for i in index:
# since self.curr_goal_sets is in a structure of list in a list
# we should iterate through the list completely
print(("Tower " + self.curr_goal_sets[i][0].args[0]), end=' ')
if (len(self.curr_goal_sets[i]) == 1):
print(("(" + str(len(self.curr_goal_sets[i])) + " Block)"))
else:
print(("(" + str(len(self.curr_goal_sets[i])) + " Blocks)"))
for j in self.curr_goal_sets[i]:
#print(j)
self.selected_goals.append(j)
#print("")
print("]")
print("")
return self.selected_goals
def next_goal_30(self):
'''
Generate the goals from the 30 sets
'''
actual_time = self.mem.get(self.mem.ACTUAL_TIME_CONSTRUCTION)
expected_time = self.mem.get(self.mem.EXPECTED_TIME_CONSTRUCTION)
selected_buildings = self.mem.get(self.mem.SELECTED_BUILDING_LIST)
complete_buildings = self.mem.get(self.mem.COMPLETE_BUILDING_LIST)
executed_buildings = self.mem.get(self.mem.EXECUTED_BUILDING_LIST)
actual_scores = self.mem.get(self.mem.ACTUAL_SCORES)
P = self.mem.get(self.mem.P)
t = self.mem.get(self.mem.t)
P = str(P)
t = str(t)
P = P.replace("[...]", "")
t = t.replace("[...]", "")
if not actual_scores:
actual_scores = 0
if executed_buildings:
expected_scores = sum(selected_buildings)
else:
expected_scores = 0
if complete_buildings:
if expected_time:
expected_p_t = float(expected_scores / expected_time)
else:
e_t = None
e_p_t = None
e_s = None
if actual_time:
actual_p_t = float(actual_scores / actual_time)
else:
a_t = None
a_s = None
a_p_t = None
myfile = open('evaluation.csv', "a")
writer = csv.writer(myfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
with open("evaluation.csv", "a") as myfile:
if expected_time:
e_t = round(expected_time, 2)
e_p_t = round(expected_p_t, 2)
if actual_time:
a_t = round(actual_time, 2)
a_p_t = round(actual_p_t, 2)
if expected_scores:
e_s = round(expected_scores, 2)
if expected_scores == 0:
e_s = 0
if actual_scores:
a_s = round(actual_scores, 2)
if actual_scores == 0:
a_s = 0
e_b = executed_buildings
data = [
self.count, complete_buildings, selected_buildings, e_t,
a_t, e_s, a_s, e_p_t, a_p_t, e_b,
str(P),
str(t)
]
writer.writerow(data)
self.mem.set(self.mem.ACTUAL_TIME_CONSTRUCTION, None)
self.mem.set(self.mem.EXPECTED_TIME_CONSTRUCTION, None)
self.mem.set(self.mem.SELECTED_BUILDING_LIST, None)
self.mem.set(self.mem.COMPLETE_BUILDING_LIST, None)
self.mem.set(self.mem.EXECUTED_BUILDING_LIST, None)
self.mem.set(self.mem.ACTUAL_SCORES, None)
self.mem.set(self.mem.P, None)
self.mem.set(self.mem.t, None)
else:
myfile = open('evaluation.csv', "a")
writer = csv.writer(myfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_ALL)
data = [
"S.NO", "PROBLEM SET", "SELECTED TOWERS", "EXPECTED TIME",
"ACTUAL TIME", "EXPECTED SCORES", "ACTUAL SCORES",
"EXPECTED(P/T)", "ACTUAL(P/T) ", "CONSTRUCTED BUILDINGS", "P",
"t"
]
writer.writerow(data)
self.curr_goal_sets[:] = []
objs_names = self.world.get_objects_names_by_type("BLOCK")
# remove the object table since we need only blocks
objs_names.remove("table")
random.shuffle(objs_names)
# builds the gaol sets
self.build_current_goal_sets(objs_names)
atoms = self.world.get_atoms()
self.remove_bunch_atoms(atoms)
stateread.apply_state_file(self.world, self.stateFile)
stateread.apply_state_str(self.world, self.state_str)
self.mem.add(self.mem.STATES, copy.deepcopy(self.world))
self.mem.set(self.mem.TIME_CONSTRUCTION, self.Time)
#print(self.world)
# empty the selected goals list
del self.selected_goals[:]
with open('30_problem_set_ijcai.pickle', 'rb') as handle:
a = pickle.load(handle)
b = a[self.count]
self.count = self.count + 1
select_buildings = b[1]
print(("NO.OF BUILDINGS TO CONSTRUCT: " + str(select_buildings)))
# this is for the random indexes , that should be taken from the variable self.curr_goal_sets
# compute the index list with in the range of 0 and no:of buildings
index = b[2]
self.curr_goal_sets = b[0]
print("THE BUILDINGS ARE: ")
print("[")
for i in index:
# since self.curr_goal_sets is in a structure of list in a list
# we should iterate through the list completely
print(("Tower " + self.curr_goal_sets[i][0].args[0]), end=' ')
if (len(self.curr_goal_sets[i]) == 1):
print(("(" + str(len(self.curr_goal_sets[i])) + " Block)"))
else:
print(("(" + str(len(self.curr_goal_sets[i])) + " Blocks)"))
for j in self.curr_goal_sets[i]:
#print(j)
self.selected_goals.append(j)
#print("")
print("]")
print("")
return self.selected_goals
def createMIDCAObj(self):
# in this demo, always keep extinguish to false
extinguish = False
thisDir = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
MIDCA_ROOT = thisDir + "/../"
domainFile = MIDCA_ROOT + "worldsim/domains/arsonist.sim"
stateFile = MIDCA_ROOT + "worldsim/states/defstate.sim"
self.world = domainread.load_domain(domainFile)
stateread.apply_state_file(self.world, stateFile)
# creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(self.world,
display=asqiiDisplay,
verbose=4)
#asqiiDisplay(world)
# add phases by name
for phase in [
"Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan",
"Act"
]:
myMidca.append_phase(phase)
# add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
# need to make sure to disable all user input modules #myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner(extinguish))
myMidca.append_module("Act", act.SimpleAct())
myMidca.insert_module(
'Simulate',
simulator.ArsonSimulator(arsonChance=self.arsonChanceArg,
arsonStart=10), 1)
myMidca.insert_module('Simulate', simulator.FireReset(), 0)
myMidca.insert_module('Interpret', guide.TFStack(), 1)
if self.usingTFTreeFire:
myMidca.insert_module('Interpret', guide.TFFire(), 2)
if self.usingSimulatedMA:
myMidca.insert_module('Interpret', guide.ReactiveApprehend(), 3)
myMidca.insert_module(
'Eval', evaluate.Scorer(),
1) # this needs to be a 1 so that Scorer happens AFTER SimpleEval
def preferApprehend(goal1, goal2):
if 'predicate' not in goal1 or 'predicate' not in goal2:
return 0
elif goal1['predicate'] == 'free' and goal2['predicate'] != 'free':
return -1
elif goal1['predicate'] != 'free' and goal2['predicate'] == 'free':
return 1
elif goal1['predicate'] == 'onfire' and goal2[
'predicate'] != 'onfire':
return -1
elif goal1['predicate'] != 'onfire' and goal2[
'predicate'] == 'onfire':
return 1
return 0
# tells the PhaseManager to copy and store MIDCA states so they can be accessed later.
myMidca.storeHistory = False
myMidca.initGoalGraph(cmpFunc=preferApprehend)
## DO NOT DO THIS: experiment.py will do this automatically: myMidca.init()
print("Created MIDCA " + str(id(myMidca)) + " w/ arsonchance=" +
str(self.arsonChanceArg) + ", usingTFTreeFire=" +
str(self.usingTFTreeFire) + ",usingSimMA=" +
str(self.usingSimulatedMA))
self.myMidca = myMidca
self.initialized = True
thisDir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
MIDCA_ROOT = thisDir + "/../"
domainFile = MIDCA_ROOT + "domains/blocksworld/domains/arsonist_extinguish.sim"
stateFile = MIDCA_ROOT + "domains/blocksworld/states/extinguisher_state.sim"
extinguish = True
argsPyHopPlanner = [util.pyhop_state_from_world,
util.pyhop_tasks_from_goals,
DECLARE_METHODS_FUNC,
DECLARE_OPERATORS_FUNC,
extinguish]
world = domainread.load_domain(domainFile)
stateread.apply_state_file(world, stateFile)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display = util.asqiiDisplay, verbose=4)
#add phases by name
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner(*argsPyHopPlanner))
GOAL_GRAPH_CMP_FUNC = util.preferApprehend
extinguish=False
mortar=True
world = domainread.load_domain(DOMAIN_FILE)
# for state file, need to add number of mortar blocks to begin with
state_str = open(STATE_FILE).read() # first read file
# now add new mortar blocks
for i in range(MORTAR_COUNT):
state_str+="MORTARBLOCK(M"+str(i)+")\n"
state_str+="available(M"+str(i)+")\n"
# now load the state
stateread.apply_state_str(world, state_str)
stateread.apply_state_file(world, STATE_FILE)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display = DISPLAY_FUNC, verbose=4, metaEnabled=True)
#add phases by name
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer(display=DISPLAY_FUNC))
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
print thisDir
MIDCA_ROOT = thisDir + "/../"
print MIDCA_ROOT
### Domain Specific Variables
DOMAIN_ROOT = MIDCA_ROOT + "domains/logistics/"
DOMAIN_FILE = DOMAIN_ROOT + "domains/domain2.sim"
STATE_FILE = DOMAIN_ROOT + "states/defstate2.sim"
### Domain Specific Variables for JSHOP planner
JSHOP_DOMAIN_FILE = MIDCA_ROOT + "domains/jshop_domains/logistics/logistics"
JSHOP_STATE_FILE = MIDCA_ROOT + "domains/jshop_domains/logistics/problem"
world = domainread.load_domain(DOMAIN_FILE)
stateread.apply_state_file(world, STATE_FILE)
#creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(world, display='', verbose=4)
#add phases by name
for phase in [
"Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"
]:
myMidca.append_phase(phase)
#add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
#myMidca.append_module("Simulate", simulator.ASCIIWorldViewer(display=DISPLAY_FUNC))
myMidca.append_module("Perceive", perceive.PerfectObserverWithThief())
myMidca.append_module("Interpret", guide.DeliverGoal())
#myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval2())
def createMIDCAObj(self):
# in this demo, always keep extinguish to false
extinguish = False
thisDir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
MIDCA_ROOT = thisDir + "/../"
domainFile = MIDCA_ROOT + "worldsim/domains/arsonist.sim"
stateFile = MIDCA_ROOT + "worldsim/states/defstate.sim"
self.world = domainread.load_domain(domainFile)
stateread.apply_state_file(self.world, stateFile)
# creates a PhaseManager object, which wraps a MIDCA object
myMidca = base.PhaseManager(self.world, display=asqiiDisplay,verbose=4)
#asqiiDisplay(world)
# add phases by name
for phase in ["Simulate", "Perceive", "Interpret", "Eval", "Intend", "Plan", "Act"]:
myMidca.append_phase(phase)
# add the modules which instantiate basic blocksworld operation
myMidca.append_module("Simulate", simulator.MidcaActionSimulator())
myMidca.append_module("Simulate", simulator.ASCIIWorldViewer())
myMidca.append_module("Perceive", perceive.PerfectObserver())
myMidca.append_module("Interpret", note.ADistanceAnomalyNoter())
# need to make sure to disable all user input modules #myMidca.append_module("Interpret", guide.UserGoalInput())
myMidca.append_module("Eval", evaluate.SimpleEval())
myMidca.append_module("Intend", intend.SimpleIntend())
myMidca.append_module("Plan", planning.PyHopPlanner(extinguish))
myMidca.append_module("Act", act.SimpleAct())
myMidca.insert_module('Simulate', simulator.ArsonSimulator(arsonChance=self.arsonChanceArg, arsonStart=10), 1)
myMidca.insert_module('Simulate', simulator.FireReset(), 0)
myMidca.insert_module('Interpret', guide.TFStack(), 1)
if self.usingTFTreeFire:
myMidca.insert_module('Interpret', guide.TFFire(), 2)
if self.usingSimulatedMA:
myMidca.insert_module('Interpret', guide.ReactiveApprehend(), 3)
myMidca.insert_module('Eval', evaluate.Scorer(), 1) # this needs to be a 1 so that Scorer happens AFTER SimpleEval
def preferApprehend(goal1, goal2):
if 'predicate' not in goal1 or 'predicate' not in goal2:
return 0
elif goal1['predicate'] == 'free' and goal2['predicate'] != 'free':
return -1
elif goal1['predicate'] != 'free' and goal2['predicate'] == 'free':
return 1
elif goal1['predicate'] == 'onfire' and goal2['predicate'] != 'onfire':
return -1
elif goal1['predicate'] != 'onfire' and goal2['predicate'] == 'onfire':
return 1
return 0
# tells the PhaseManager to copy and store MIDCA states so they can be accessed later.
myMidca.storeHistory = False
myMidca.initGoalGraph(cmpFunc=preferApprehend)
## DO NOT DO THIS: experiment.py will do this automatically: myMidca.init()
print "Created MIDCA "+str(id(myMidca))+" w/ arsonchance="+str(self.arsonChanceArg)+", usingTFTreeFire="+str(self.usingTFTreeFire)+",usingSimMA="+str(self.usingSimulatedMA)
self.myMidca = myMidca
self.initialized = True
