StableBaselines3 / 步骤 vs.total_timestepsvs.训练期间解决环境的次数

Question

model.learn(total_timesteps=20)

花费的时间比我预期的要长得多，所以我试图了解我是否应该：

1. 节约时间步骤
2. 加速我的环境

   env.step(action)

3. 训练更多时间步数

---

考虑一个简单的环境：

• 还有 (x3) 个步骤，直到

  done=True

我预计

model.learn(total_timesteps=20)

会选择：

1. 20 x 3 步骤 = 20 次迭代（相当于 20 集）
2. 总共 20 个步骤（或者可能 18 或 21 个步骤）= (x6) 或 (x7) 集

---

这是一个类似的问题，没有答案：Stackoverflow问题A。

这个答案（Stackoverflow 问题 B）意味着这确实是

env

的所有迭代的总步数。如果是这种情况，在上面的示例中，它应该在停止之前运行 (x18) 个步骤或 (x6) 次。然而，完成它需要的时间要长得多（我已经计时了！）。 为什么会这样？

• total_timesteps

  的正确解释是什么？
• 详细描述这一点的文档在哪里（不在这里...链接）？

---

示例：受到 Nicholas Renotte 教程的启发项目 3 - 自定义环境

在下面的示例中，请注意：

1. 每个环境只能精确执行 (x3) 个步骤
2. 运行所需的时间

   episodes

   非常非常小

3. total_timesteps

   与

   episodes

的循环次数相同

4. iterations

   和

   time_elapsed

   的总结似乎与

   total_timesteps

无关

环境类

class ShowerEnv(Env):
    listTemperatureKnob = (10, 30, 50)
    shower_length = 3

    def __init__(self):
        self.action_space = Discrete(3)
        self.observation_space = Box(low=np.array([0], dtype=np.float32), high=np.array([100], dtype=np.float32))
        self.reset()
        
    def step(self, action):
        temperatureShowerHead = self.listTemperatureKnob[action]
        self.state = temperatureShowerHead
        self.shower_length -= 1 

        if self.state > 27 and self.state < 33: 
            reward =1 
        else: 
            reward = -1 
        
        if self.shower_length <= 0: 
            done = True
        else:
            done = False
        
        # Apply temperature noise
        #self.state += random.randint(-1,1)
        # Set placeholder for info
        info = {"temperatureShower":temperatureShowerHead}

        obs = np.array([self.state], dtype=np.float32)
        # Return step information
        return obs, reward, done, info

    def render(self):
        pass
    
    def reset(self):
        self.state = self.listTemperatureKnob[0]
        self.shower_length = 3
        obs = np.array([self.state], dtype=np.float32)

        return obs

env = ShowerEnv()
check_env(env, warn=True)

奔跑 (x5) 集

timeStart = time.time()

episodes = 5
for episode in range(1, episodes+1):
    state = env.reset()
    done = False
    score = 0 
    
    while not done:
        env.render()
        action = env.action_space.sample()
        n_state, reward, done, info = env.step(action)
        score+=reward
    print('Episode:{} Score:{}'.format(episode, score))
env.close()

timeEnd = time.time()
print("Elapsed Time: " + str(timeEnd- timeStart))

已用时间：0.000999

执行

model

培训

log_path = os.path.join('Training', 'Logs')
model = PPO("MlpPolicy", env, verbose=1, tensorboard_log=log_path)

timeStart = time.time()
model.learn(total_timesteps=5)

timeEnd = time.time()
print("Elapsed Time: " + str(timeEnd- timeStart))

输出

Using cpu device
Wrapping the env with a `Monitor` wrapper
Wrapping the env in a DummyVecEnv.
Logging to Training\Logs\PPO_7
---------------------------------
| rollout/           |          |
|    ep_len_mean     | 3        |
|    ep_rew_mean     | -1.14    |
| time/              |          |
|    fps             | 1496     |
|    iterations      | 1        |
|    time_elapsed    | 1        |
|    total_timesteps | 2048     |
---------------------------------

已用时间：2.6916

Answer 1

我最近和你分享了同样的困惑：当我将total_timesteps设置为非常小的值（例如1）时，训练过程比我预期的要长得多。但我刚刚意识到这是由于SB3中的PPO类需要一个名为n_steps的参数造成的。

n_steps 表示策略更新前的步数，默认设置为 2048。这就是为什么当我给total_steps 赋予小于 2048 的值时，训练过程总是会经过 2048 步。我手动将n_steps设置为较小的值后，问题就解决了。

所以对于你的情况，如果你

预计

model.learn(total_timesteps=20)

采取以下任一措施：

1. 20 x 3 步骤 = 20 次迭代（相当于 20 集）
2. 总共 20 个步骤（或者可能 18 或 21 个步骤）= (x6) 或 (x7) 集

您可以分别尝试：

1. model = PPO(policy, env, n_steps=3).learn(total_timesteps=60)

2. model = PPO(policy, env, n_steps=3).learn(total_timesteps=20)

有关n_steps的更多信息，您可以参考这里PPO文档中的参数部分，但请注意n_steps * n_envs必须大于1，这意味着如果您的情况只有一个环境，则n_steps的值必须大于 1。

希望这有帮助！