Python Agent.load_model方法代码示例

# 需要导入模块: from agent import Agent [as 别名]
# 或者: from agent.Agent import load_model [as 别名]
def main(env_name, monitor=True, load=False, seed=0, gpu=-1):

    env = gym.make(env_name)
    view_path = "./video/" + env_name
    model_path = "./model/" + env_name + "_"

    n_st = env.observation_space.shape[0]
    n_act = env.action_space.n

    agent = Agent(n_act, seed, gpu)
    if load:
        agent.load_model(model_path)

    if monitor:
        env.monitor.start(view_path, video_callable=None, force=True, seed=seed)
    for i_episode in xrange(10000):
        observation = env.reset()
        agent.reset_state(observation)
        ep_end = False
        q_list = []
        r_list = []
        while not ep_end:
            action = agent.act()
            observation, reward, ep_end, _ = env.step(action)
            agent.update_experience(observation, action, reward, ep_end)
            agent.train()
            q_list.append(agent.Q)
            r_list.append(reward)
            if ep_end:
                agent.save_model(model_path)
                break
        print('%i\t%i\t%f\t%i\t%f' % (i_episode, agent.step, agent.eps, sum(r_list), sum(q_list)/float(len(q_list))))
    if monitor:
        env.monitor.close()

# 需要导入模块: from agent import Agent [as 别名]
# 或者: from agent.Agent import load_model [as 别名]
def main(env_name, render=False, monitor=True, load=False, seed=0):

    env = gym.make(env_name)
    view_path = "./video/" + env_name
    model_path = "./model/" + env_name + "_"

    n_st = env.observation_space.shape[0]
    if type(env.action_space) == gym.spaces.discrete.Discrete:
        # CartPole-v0, Acrobot-v0, MountainCar-v0
        n_act = env.action_space.n
        action_list = range(0, n_act)
    elif type(env.action_space) == gym.spaces.box.Box:
        # Pendulum-v0
        action_list = [np.array([a]) for a in [-2.0, 2.0]]
        n_act = len(action_list)

    agent = Agent(n_st, n_act, seed)
    if load:
        agent.load_model(model_path)

    if monitor:
        env.monitor.start(view_path, video_callable=None, force=True, seed=seed)
    for i_episode in xrange(1000):
        observation = env.reset()
        r_sum = 0
        q_list = []
        for t in xrange(200):
            if render:
                env.render()
            state = observation.astype(np.float32).reshape((1,n_st))
            act_i, q = agent.get_action(state)
            q_list.append(q)
            action = action_list[act_i]
            observation, reward, ep_end, _ = env.step(action)
            state_dash = observation.astype(np.float32).reshape((1,n_st))
            agent.stock_experience(state, act_i, reward, state_dash, ep_end)
            agent.train()
            r_sum += reward
            if ep_end:
                break
        print "\t".join(map(str,[i_episode, r_sum, agent.epsilon, agent.loss, sum(q_list)/float(t+1) ,agent.step]))
        agent.save_model(model_path)
    if monitor:
        env.monitor.close()

# 需要导入模块: from agent import Agent [as 别名]
# 或者: from agent.Agent import load_model [as 别名]
class Environment:
    def __init__(self, config):
        config.model_type = Config.MODEL_TYPE_CONV2D

        print(config.device)
        self.config = config
        self.env = wrap_deepmind(make_atari(config.env), frame_stack=True)
        self.num_states = self.env.observation_space.shape[-1]
        self.num_actions = self.env.action_space.n
        self.agent = Agent(config, self.num_states, self.num_actions, self.config.num_atoms)
        self.total_step = np.zeros(100)

        self.data_path = config.data_path
        if self.data_path != Config.DATA_PATH_DEFAULT:
            self.agent.load_model()

    def prepro(self, observation):
        ret = np.zeros((4, 84, 84))
        ret[0] = observation[:, :, 0]
        ret[1] = observation[:, :, 1]
        ret[2] = observation[:, :, 2]
        ret[3] = observation[:, :, 3]
        return ret

    def run_episode(self, episode, steps_accumulated=0):
        start_time = time.time()
        total_reward = 0
        observation = self.prepro(self.env.reset())
        state = torch.from_numpy(observation).to(self.config.device, dtype=torch.uint8).unsqueeze(0)

        for step in range(self.config.num_steps):
            if self.config.is_render:
                time.sleep(0.064)
                self.env.render()

            action = self.agent.get_action(state, step + steps_accumulated)

            observation_next, reward, done, _ = self.env.step(action.item())

            if done:
                state_next = None
                self.total_step = np.hstack((self.total_step[1:], step + 1))
            else:
                state_next = self.prepro(observation_next)
                state_next = torch.from_numpy(state_next).to(self.config.device, dtype=torch.uint8).unsqueeze(0)

            total_reward += reward
            reward = torch.tensor([reward], dtype=torch.uint8, device=self.config.device)

            if not self.config.is_render:
                self.agent.observe(state, action, state_next, reward)
                if step % self.config.replay_interval == 0:
                    self.agent.learn(episode)

            state = state_next

            if done:
                elapsed_time = round(time.time() - start_time, 3)
                print('episode: {0}, steps: {1}, mean steps {2}, time: {3}, reward: {4}'.format(episode, step, self.total_step.mean(), elapsed_time, total_reward))
                return step + 1

        return self.config.num_steps

    def run(self):
        if not self.config.is_render:
            steps = 0
            while True:
                steps += self.run_episode(-1)
                if self.config.steps_learning_start <= steps:
                    break

        steps = 0
        for episode in range(self.config.num_episodes):
            steps += self.run_episode(episode, steps)

        self.env.close()

        if self.config.is_saved:
            self.agent.save_model()