class CarApp(App):
def build(self):
self.paused = True
self.last_size = [0, 0]
self.goals = []
self.parent = Game()
parent = self.parent
sec_num = 6
box_size = 400
self.brain = Dqn(sec_num * 2 + 2, 3, 0.9)
circle = Circle()
dest = Destinity()
parent.serve_car(circle=circle,
dest=dest,
sec_num=sec_num,
box_size=box_size,
brain=self.brain,
goals=self.goals)
Clock.schedule_interval(self.pauseCheck, 1.0 / 60.0)
#Clock.schedule_interval(parent.update, 0)
self.painter = MyPaintWidget(self.goals)
clearbtn = Button(text='clear')
savebtn = Button(text='save', pos=(parent.width, 0))
loadbtn = Button(text='load', pos=(2 * parent.width, 0))
self.pausebtn = Button(text='start', pos=(3 * parent.width, 0))
plotbtn = Button(text='plot', pos=(4 * parent.width, 0))
self.setGoalsbtn = Button(text='drawing', pos=(5 * parent.width, 0))
clearbtn.bind(on_release=self.clear_canvas)
savebtn.bind(on_release=self.save)
loadbtn.bind(on_release=self.load)
self.pausebtn.bind(on_release=self.pauseSwitch)
plotbtn.bind(on_release=self.plot)
self.setGoalsbtn.bind(on_release=self.setGoals)
parent.add_widget(self.painter)
parent.add_widget(clearbtn)
parent.add_widget(savebtn)
parent.add_widget(loadbtn)
parent.add_widget(self.pausebtn)
parent.add_widget(plotbtn)
parent.add_widget(self.setGoalsbtn)
parent.add_widget(dest)
parent.add_widget(circle)
return parent
def pauseCheck(self, dt):
if self.paused == False:
self.parent.update()
else:
if self.last_size != self.parent.size:
print("resized")
global longueur
global largeur
longueur = self.parent.width
largeur = self.parent.height
self.parent.car.center[0] = longueur * 0.5
self.parent.car.center[1] = largeur * 0.125
self.painter.canvas.clear()
init()
self.parent.update()
del self.goals[:]
print('goals cleared')
self.last_size[0] = self.parent.size[0]
self.last_size[1] = self.parent.size[1]
shrink_updated = False
def pauseSwitch(self, obj):
self.paused = 1 - self.paused
if self.paused == True:
self.pausebtn.text = 'start'
else:
self.pausebtn.text = 'pause'
self.parent.updateGoal()
def setGoals(self, obj):
self.painter.setgoals = 1 - self.painter.setgoals
if self.painter.setgoals == True:
self.setGoalsbtn.text = 'setting goals'
else:
self.setGoalsbtn.text = 'drawing'
del self.goals[:]
print('goals cleared')
def plot(self, obj):
plt.plot(scores)
plt.show()
def clear_canvas(self, obj):
global sand
self.painter.canvas.clear()
sand = np.zeros((longueur, largeur))
shrink_updated = False
def save(self, obj):
print("saving brain...")
self.brain.save()
plt.plot(scores)
plt.show()
def load(self, obj):
print("loading last saved brain...")
self.brain.load()
plt.savefig('progression.png')
last_reward = 0
memo = []
brain = Dqn((1, 80, 80), 3, 0.9)
condition = True
last_state = np.zeros((1, 80, 80))
counter = 0
steps_count = 0
mean_steps = 0
scores = []
up_pressed = False
dino = cv2.cvtColor(cv2.imread('game_over.png'), cv2.COLOR_BGR2GRAY)
w, h = dino.shape[:2]
brain.load()
while (condition):
action = brain.update(last_reward, last_state)
if action == 2:
pyautogui.keyUp('down')
pyautogui.keyDown('up')
elif action == 0:
pyautogui.keyUp('up')
pyautogui.keyUp('down')
else:
pyautogui.keyUp('up')
pyautogui.keyDown('down')
#
screen = np.array(ImageGrab.grab(bbox=(5, 155, 600, 296)))
class AgentRealistic:
def __init__(self,agent_host,agent_port, mission_type, mission_seed, solution_report, state_space_graph):
""" Constructor for the realistic agent """
self.AGENT_MOVEMENT_TYPE = 'Discrete' #This can be varied between the following - {Absolute, Discrete, Continuous}
self.AGENT_NAME = 'Realistic'
self.AGENT_ALLOWED_ACTIONS = ["movenorth 1", "movesouth 1", "movewest 1", "moveeast 1"]
self.agent_host = agent_host
self.agent_port = agent_port
self.mission_seed = mission_seed
self.mission_type = mission_type
self.state_space = None; # Note - To be a true Realistic Agent, it can not know anything about the state_space a priori!
self.solution_report = solution_report;
self.solution_report.setMissionType(self.mission_type)
self.solution_report.setMissionSeed(self.mission_seed)
self.last_reward = 0
self.accumulative_reward = 0
self.brain = Dqn(2, len(self.AGENT_ALLOWED_ACTIONS), 0.9)
self.brain.load()
#----------------------------------------------------------------------------------------------------------------#
def __ExecuteActionForRealisticAgentWithNoisyTransitionModel__(self, idx_requested_action, noise_level):
""" Creates a well-defined transition model with a certain noise level """
n = len(self.AGENT_ALLOWED_ACTIONS)
pp = noise_level/(n-1) * np.ones((n,1))
pp[idx_requested_action] = 1.0 - noise_level
idx_actual = np.random.choice(n, 1, p=pp.flatten()) # sample from the distribution of actions
actual_action = self.AGENT_ALLOWED_ACTIONS[int(idx_actual)]
self.agent_host.sendCommand(actual_action)
return actual_action
#----------------------------------------------------------------------------------------------------------------#
def run_agent(self):
""" Run the Realistic agent and log the performance and resource use """
partialReward = 0
#-- Load and initiate mission --#
print('Generate and load the ' + self.mission_type + ' mission with seed ' + str(self.mission_seed) + ' allowing ' + self.AGENT_MOVEMENT_TYPE + ' movements')
mission_xml = init_mission(self.agent_host, self.agent_port, self.AGENT_NAME, self.mission_type, self.mission_seed, self.AGENT_MOVEMENT_TYPE)
self.solution_report.setMissionXML(mission_xml)
self.solution_report.start()
time.sleep(1)
state_t = self.agent_host.getWorldState()
first = True
# -- Get a state-space model by observing the Orcale/GridObserver--#
while state_t.is_mission_running:
if first:
time.sleep(2)
first = False
# -- Basic map --#
state_t = self.agent_host.getWorldState()
if state_t.number_of_observations_since_last_state > 0:
msg = state_t.observations[-1].text # Get the details for the last observed state
oracle_and_internal = json.loads(msg) # Parse the Oracle JSON
grid = oracle_and_internal.get(u'grid', 1)
xpos = oracle_and_internal.get(u'XPos', 1)
zpos = oracle_and_internal.get(u'ZPos', 1)
ypos = oracle_and_internal.get(u'YPos', 1)
yaw = oracle_and_internal.get(u'Yaw', 1)
pitch = oracle_and_internal.get(u'Pitch', 1)
#last_signal = [xpos, zpos, ypos, yaw, pitch]
last_signal = [xpos, ypos]
action = self.brain.update(self.last_reward, last_signal)
print("Requested Action:", self.AGENT_ALLOWED_ACTIONS[action])
self.__ExecuteActionForRealisticAgentWithNoisyTransitionModel__(action, 0.1)
time.sleep(0.02)
self.solution_report.action_count = self.solution_report.action_count + 1
for reward_t in state_t.rewards:
partialReward += reward_t.getValue()
#self.last_reward = reward_t.getValue()
self.accumulative_reward += reward_t.getValue()
self.solution_report.addReward(reward_t.getValue(), datetime.datetime.now())
print("Reward_t:",reward_t.getValue())
print("Cummulative reward so far:", self.accumulative_reward)
print("Last Reward:{0}".format(partialReward))
self.last_reward = partialReward
partialReward = 0
return
class CarApp(App):
scores = []
game_widget = None
right_panel = None
paused = False
current_popup = None
config_widget = None
top_panel = None
stats_widget = None
map_dialog = None
def __init__(self, **kwargs):
super(CarApp, self).__init__(**kwargs)
self.painter = PaintWidget()
self.self_driving_config = Configuration()
self.self_driving_config.load()
self.brain = Dqn(6, 3, self.self_driving_config)
def build(self):
self.game_widget = Game()
self.game_widget.driving_config = self.self_driving_config
self.game_widget.brain = self.brain
self.game_widget.scores = self.scores
self.game_widget.serve_car()
Clock.schedule_interval(self.game_widget.update, 1.0 / 60.0)
self.painter.game = self.game_widget
self.game_widget.add_widget(self.painter)
self.top_panel = TopPanel()
self.top_panel.graph_widget.game_widget = self.game_widget
self.game_widget.stats_widget = self.top_panel.stats_widget
action_bar = TopMenuWidget()
action_bar.pause_btn.bind(on_release=self.pause_resume)
action_bar.save_brain_button.bind(on_release=self.save_brain)
action_bar.save_map_button.bind(on_release=self.show_save_map)
action_bar.load_btn.bind(on_release=self.load)
action_bar.load_map_btn.bind(on_release=self.show_load_map)
action_bar.clear_btn.bind(on_release=self.clear_canvas)
action_bar.config_btn.bind(on_release=self.show_configuration)
root = RootWidget()
root.add_widget(action_bar)
root.add_widget(self.top_panel)
root.add_widget(self.game_widget)
return root
def put_stats(self, dt):
print("Checking for stats")
if self.top_panel.stats_widget is None:
return
print("stats widget now available")
return False
def pause_resume(self, btn=None):
self.paused = not self.paused
self.game_widget.pause_resume()
self.top_panel.graph_widget.pause_resume()
if not self.paused:
Clock.schedule_interval(self.game_widget.update, 1.0 / 60.0)
def clear_canvas(self, obj=None):
self.painter.canvas.clear()
self.game_widget.reset_sand()
def save_brain(self, obj):
print("saving brain...")
self.brain.save()
def show_save_map(self, obj):
self.pause_resume()
self.map_dialog = MapDialog()
self.current_popup = Popup(content=self.map_dialog,
auto_dismiss=False,
title='Save Map',
size_hint=(None, None),
size=(400, 200))
self.map_dialog.save_btn.bind(on_release=self.map_dialog_action)
self.map_dialog.cancel_btn.bind(on_release=self.close_popup)
self.current_popup.open()
def show_load_map(self, obj):
self.pause_resume()
self.map_dialog = MapDialog(save_mode=False)
self.current_popup = Popup(content=self.map_dialog,
auto_dismiss=False,
title='Load Map',
size_hint=(None, None),
size=(400, 200))
self.map_dialog.save_btn.bind(on_release=self.map_dialog_action)
self.map_dialog.cancel_btn.bind(on_release=self.close_popup)
self.current_popup.open()
def map_dialog_action(self, btn):
if self.map_dialog.save_mode:
self.painter.save(self.map_dialog.filename_input.text)
else:
self.clear_canvas()
self.painter.load(self.map_dialog.filename_input.text)
self.current_popup.dismiss()
self.pause_resume()
def load(self, obj):
print("loading last saved brain...")
self.brain.load()
def show_configuration(self, btn):
self.pause_resume()
self.config_widget = ConfigurationWidget()
self.config_widget.set_config(self.self_driving_config)
self.current_popup = Popup(content=self.config_widget,
auto_dismiss=False,
title='Configuration')
self.current_popup.open()
self.config_widget.save_btn.bind(on_release=self.save_configuration)
self.config_widget.cancel_btn.bind(on_release=self.close_popup)
def save_configuration(self, btn):
self.pause_resume()
self.self_driving_config.update(self.config_widget.get_dict())
self.game_widget.update_config(self.self_driving_config)
self.clear_canvas()
self.current_popup.dismiss()
def close_popup(self, btn):
self.pause_resume()
self.current_popup.dismiss()