def step_gen(self):
#print "running generator"
all_goal_coords = [self.real_goal] + self.poss_goals
goal_obs = d.generateGoalObs(self.mapref, self.start, all_goal_coords)
rmp, argmin = d.rmp(self.mapref, self.start, goal_obs)
heatmap = d.HeatMap(self.mapref, goal_obs)
target = d.findTarget(self.mapref, rmp, argmin, self.real_goal, heatmap)
path1 = self.mapref.optPath(self.start,target)
path2 = self.mapref.optPath(target, self.real_goal)
path = path1[1:] + path2[1:]
self.path2 = path2
for step in path:
yield step
def runBatch(self):
"""
Read problems, generate observed path and run agents corresponding to each strategy number.
"""
print "Running batch..."
#Directly modify prior to run - e.g. limit to one quality, one density, etc.
densities = (10, 25, 50, 75, 90, 99) #percentage of path
#strategyNums = (0,1,2,3,4) #strategy zero is Astar
strategyNums = (1, 2) #strategy zero is Astar
with open(self.infile, 'r') as f:
reader = csv.reader(f)
next(reader) #skip header row
counter = 1
for problem in reader:
print "Processing problem " + str(counter)
counter = counter + 1
map, optcost = problem[:2] #first two elements
optcost = float(optcost)
problem_ints = [int(i) for i in problem[2:]
] #remaining elements, all integers
numgoals, scol, srow, gcol, grow = problem_ints[:5]
start = (scol, srow)
realgoal = (gcol, grow)
possgoals = []
for i in range(numgoals):
possgoals.append(
(problem_ints[5 + i * 2], problem_ints[6 + i * 2]))
if not self.map == map:
model = LogicalMap(MAP_PATH + map)
self.map = map
#initialise deceptor
all_goal_coords = [realgoal] + possgoals
goal_obs = d.generateGoalObs(model, start, all_goal_coords)
heatmap = d.HeatMap(model, goal_obs)
#one loop to generate paths, extract obs, get probabilities, and write to csv
for s in strategyNums:
print "strategy" + str(s)
#get path and its cost - depends on obs_agent - i.e. strat1, strat2, strat3, strat4
if not s: #strategy zero (astar)
clockstart = timer()
pathcost, fullpath = model.optPath(start, realgoal, 2)
clockend = timer()
""" add this code to return path up to rmp only
# rmp, argmin = d.rmp(model, start, goal_obs)
# target = pathcost-rmp
# prev = start
# cost = 0
# stepnum = 0
# while cost < target:
# stepnum = stepnum + 1
# step = fullpath[stepnum]
# cost = cost + model.getCost(step, prev)
# prev = step
# fullpath = fullpath[:stepnum]"""
else:
clockstart = timer()
pathcost, fullpath = self.strategies[s].getFullPath(
model, start, realgoal, possgoals, heatmap)
clockend = timer()
gentime = clockend - clockstart
writearray = [map, start, s, pathcost, gentime]
for density in densities:
print "Density", str(density)
#find node at that pos
density = float(density)
totlength = len(fullpath) - 1
pathpos = int(density / 100 * totlength)
#check deceptivity
stepdecept = heatmap.isTruthful(fullpath[pathpos])
writearray.append(stepdecept)
self.outputLine(self.outfile, writearray)
print "Results written to " + self.outfile