def __init__(self):
self.layout = Layout(Const.WORLD)
Display.initGraphics(self.layout)
self.model = Model(self.layout)
self.carChanges = {}
self.errorCounter = Counter()
self.consecutiveLate = 0
def run(self):
self.render()
self.userThread = UserThread(self.model.junior, self.model)
self.userThread.start()
self.iteration = 0
while not self.isGameOver():
self.resetTimes()
startTime = time.time()
self.printStats()
self.otherCarUpdate()
self.calculateError()
duration = time.time() - startTime
timeToSleep = Const.SECONDS_PER_HEARTBEAT - duration
self.checkLate(timeToSleep)
timeToSleep = max(0.01, timeToSleep)
Display.graphicsSleep(timeToSleep)
self.iteration += 1
if not self.userThread.quit and not self.isLearning:
self.outputGameResult()
self.userThread.stop()
Display.graphicsSleep(0.1)
self.userThread.join()
return self.userThread.quit
def updateBeliefs(self):
if self.isLearning: return
beliefs = []
for car in self.model.getOtherCars():
belief = car.getInference().getBelief()
color = car.getColor()
Display.updateBelief(color, belief)
beliefs.append(belief)
self.model.setProbCar(beliefs)
def render(self):
Display.drawBelief(self.model)
Display.drawBlocks(self.model.getBlocks())
if Const.SHOW_CARS:
for car in self.model.getCars():
Display.drawCar(car)
else:
Display.drawCar(self.model.getJunior())
Display.drawFinish(self.model.getFinish())
engine.view.graphicsUtils.refresh()
def outputGameResult(self):
collided = self.userThread.hasCollided()
for car in self.model.getCars():
Display.drawCar(car)
print('*********************************')
print('* GAME OVER *')
if collided:
print('* CAR CRASH!!!!!')
else:
print('* You Win!')
print('*********************************')
def infer(self):
start = time.time()
try:
self.elapseTime()
self.observe()
except Exception as e:
print('caught')
traceback.print_exc()
Display.raiseEndGraphics()
Display.graphicsSleep(0.01)
self.userThread.quit = True
inferEnd = time.time()
self.inferTime += inferEnd - start
self.updateBeliefs()
self.drawTime += time.time() - inferEnd
def run():
parser = optparse.OptionParser()
parser.add_option('-p', '--parked', dest='parked', default=False, action='store_true')
parser.add_option('-d', '--display', dest='display', default=True, action='store_true')
parser.add_option('-k', '--numCars', type='int', dest='numCars', default=3)
parser.add_option('-l', '--layout', dest='layout', default='small')
parser.add_option('-s', '--speed', dest='speed', default='slow')
parser.add_option('-f', '--fixedSeed', dest='fixedSeed', default=False, action='store_true')
parser.add_option('-a', '--auto', dest='auto', default=False, action='store_true')
(options, _) = parser.parse_args()
Const.WORLD = options.layout
Const.CARS_PARKED = options.parked
Const.SHOW_CARS = options.display
Const.NUM_AGENTS = options.numCars
Const.INFERENCE = 'none'
Const.AUTO = options.auto
Const.SECONDS_PER_HEARTBEAT = 0.001
signal.signal(signal.SIGINT, signal_handler)
# Fix the random seed
if options.fixedSeed: random.seed('driverlessCar')
learner = Learner()
iterations = 0
numIter = Const.TRAIN_MAX_AGENTS * Const.TRAIN_PER_AGENT_COUNT
for i in range(1, Const.TRAIN_MAX_AGENTS + 1):
for j in range(Const.TRAIN_PER_AGENT_COUNT):
percentDone = int(iterations * 100.0 / numIter)
print str(percentDone) + '% done'
Const.NUM_AGENTS = i
quit = Controller().learn(learner)
if quit:
Display.endGraphics()
return
iterations += 1
transFileName = Const.WORLD + 'TransProb.p'
transFilePath = os.path.join('learned', transFileName)
with open(transFilePath, 'wb') as transFile:
learner.saveTransitionProb(transFile)
print 'saved file: ' + transFilePath
Display.endGraphics()
def run():
parser = optparse.OptionParser()
parser.add_option('-p', '--parked', dest='parked', default=False, action='store_true')
parser.add_option('-d', '--display', dest='display', default=True, action='store_true')
parser.add_option('-k', '--numCars', type='int', dest='numCars', default=3)
parser.add_option('-l', '--layout', dest='layout', default='small')
parser.add_option('-s', '--speed', dest='speed', default='slow')
parser.add_option('-f', '--fixedSeed', dest='fixedSeed', default=False, action='store_true')
parser.add_option('-a', '--auto', dest='auto', default=False, action='store_true')
(options, _) = parser.parse_args()
Const.WORLD = options.layout
Const.CARS_PARKED = options.parked
Const.SHOW_CARS = options.display
Const.NUM_AGENTS = options.numCars
Const.INFERENCE = 'none'
Const.AUTO = options.auto
Const.SECONDS_PER_HEARTBEAT = 0.001
signal.signal(signal.SIGINT, signal_handler)
# Fix the random seed
if options.fixedSeed: random.seed('driverlessCar')
learner = Learner()
iterations = 0
numIter = Const.TRAIN_MAX_AGENTS * Const.TRAIN_PER_AGENT_COUNT
for i in range(1, Const.TRAIN_MAX_AGENTS + 1):
for j in range(Const.TRAIN_PER_AGENT_COUNT):
percentDone = int(iterations * 100.0 / numIter)
print str(percentDone) + '% done'
Const.NUM_AGENTS = i
quit = Controller().learn(learner)
if quit:
Display.endGraphics()
return
iterations += 1
transFileName = Const.WORLD + 'TransProb.p'
transFilePath = os.path.join('learned', transFileName)
with open(transFilePath, 'wb') as transFile:
learner.saveTransitionProb(transFile)
print 'saved file: ' + transFilePath
Display.endGraphics()
def heartbeat(self):
oldDir = Vec2d(self.junior.dir.x, self.junior.dir.y)
oldPos = Vec2d(self.junior.pos.x, self.junior.pos.y)
quitAction = self.junior.action()
carProb = self.model.getProbCar()
if carProb and Const.AUTO:
agentGraph = self.model.getJuniorGraph()
self.junior.autonomousAction(carProb, agentGraph)
if quitAction:
self.quit = True
return
self.junior.update()
self.collision = self.model.checkCollision(self.junior)
self.victory = self.model.checkVictory()
newPos = self.junior.getPos()
newDir = self.junior.getDir()
deltaPos = newPos - oldPos
deltaAngle = oldDir.get_angle_between(newDir)
Display.move(self.junior, deltaPos)
Display.rotate(self.junior, deltaAngle)
def isGameOver(self):
if self.isLearning:
keys = Display.getKeys()
if 'q' in keys:
self.userThread.quit = True
return True
return self.iteration > Const.TRAIN_ITERATIONS
if self.userThread.quit:
return True
if self.userThread.victory:
return True
return self.userThread.hasCollided()
def signal_handler(signal, frame):
Display.raiseEndGraphics()
dest='fixedSeed',
default=False,
action='store_true')
(options, _) = parser.parse_args()
Const.WORLD = options.layout
Const.CARS_PARKED = options.parked
Const.SHOW_CARS = options.display
Const.NUM_AGENTS = options.numCars
Const.INFERENCE = options.inference
Const.SPEED = options.speed
Const.HEARTBEATS_PER_SECOND = Const.HEARTBEAT_DICT[Const.SIM_SPEED]
Const.SECONDS_PER_HEARTBEAT = 1.0 / Const.HEARTBEATS_PER_SECOND
Const.AUTO = options.auto
signal.signal(signal.SIGINT, signal_handler)
# Fix the random seed
if options.fixedSeed: random.seed('driverlessCar')
controller = Controller()
#temp = raw_input()
quit = controller.drive()
if not quit:
controller.freezeFrame()
print 'closing...'
Display.endGraphics()
def signal_handler(signal, frame):
Display.raiseEndGraphics()
Const.WORLD = options.layout
Const.CARS_PARKED = options.parked
Const.SHOW_CARS = options.display
Const.NUM_AGENTS = options.numCars
Const.INFERENCE = options.inference
Const.SPEED = options.speed
Const.HEARTBEATS_PER_SECOND = Const.HEARTBEAT_DICT[Const.SIM_SPEED]
Const.SECONDS_PER_HEARTBEAT = 1.0 / Const.HEARTBEATS_PER_SECOND
Const.AUTO = options.auto
signal.signal(signal.SIGINT, signal_handler)
# Fix the random seed
if options.fixedSeed: random.seed('driverlessCar')
QLearner = QLearningAlgorithm([0, 1])
winCount = 0
for i in range(100):
controller = Controller(QLearner)
(quit, isWin) = controller.drive()
if not quit:
controller.freezeFrame()
print 'closing...'
Display.endGraphics()
if isWin:
winCount += 1
if i % 10 == 0:
print 'iteration={0}'.format(i)
print QLearner.weights
print 'winCount={0}'.format(winCount)
def action(self):
keys = Display.getKeys()
actions = self.getActions(keys)
self.applyActions(actions)
return 'q' in keys
def moveCarDisplay(self, car, deltaPos, deltaAngle):
start = time.time()
Display.move(car, deltaPos)
Display.rotate(car, deltaAngle)
self.drawTime += time.time() - start
def freezeFrame(self):
while True:
keys = Display.getKeys()
if 'q' in keys: return
Display.graphicsSleep(0.1)
