- c - 在位数组中找到第一个零
- linux - Unix 显示有关匹配两种模式之一的文件的信息
- 正则表达式替换多个文件
- linux - 隐藏来自 xtrace 的命令
编辑:以下似乎也是 FrozenLake-v0
的情况.请注意,我对简单的 Q 学习不感兴趣,因为我想看到适用于连续观察空间的解决方案。
我最近创建了 banana_gym
OpenAI 环境。场景如下:
你有一根香蕉。它必须在 2 天内卖掉,因为它在第 3 天就会变坏。你可以选择价格x,但是香蕉只会以概率售出
奖励是x - 1。如果第三天没有卖掉香蕉,奖励是-1。 (直觉:你为香蕉支付了 1 欧元)。因此,环境是不确定的(随机的)。
Actions:您可以将价格设置为 {0.00, 0.10, 0.20, ..., 2.00}
中的任何值观察:剩余时间(source)
我计算了最优策略:
Opt at step 1: price 1.50 has value -0.26 (chance: 0.28)
Opt at step 2: price 1.10 has value -0.55 (chance: 0.41)
这也符合我的直觉:首先尝试以更高的价格出售香蕉,因为您知道如果不出售香蕉,您还会再试一次。然后将价格降低到 0.00 以上。
我很确定这个是正确的,但为了完整起见
#!/usr/bin/env python
"""Calculate the optimal banana pricing policy."""
import math
import numpy as np
def main(total_time_steps, price_not_sold, chance_to_sell):
"""
Compare the optimal policy to a given policy.
Parameters
----------
total_time_steps : int
How often the agent may offer the banana
price_not_sold : float
How much do we have to pay if we don't sell until
total_time_steps is over?
chance_to_sell : function
A function that takes the price as an input and outputs the
probabilty that a banana will be sold.
"""
r = get_optimal_policy(total_time_steps,
price_not_sold,
chance_to_sell)
enum_obj = enumerate(zip(r['optimal_prices'], r['values']), start=1)
for i, (price, value) in enum_obj:
print("Opt at step {:>2}: price {:>4.2f} has value {:>4.2f} "
"(chance: {:>4.2f})"
.format(i, price, value, chance_to_sell(price)))
def get_optimal_policy(total_time_steps,
price_not_sold,
chance_to_sell=None):
"""
Get the optimal policy for the Banana environment.
This means for each time step, calculate what is the smartest price
to set.
Parameters
----------
total_time_steps : int
price_not_sold : float
chance_to_sell : function, optional
Returns
-------
results : dict
'optimal_prices' : List of best prices to set at a given time
'values' : values of the value function at a given step with the
optimal policy
"""
if chance_to_sell is None:
chance_to_sell = get_chance
values = [None for i in range(total_time_steps + 1)]
optimal_prices = [None for i in range(total_time_steps)]
# punishment if a banana is not sold
values[total_time_steps] = (price_not_sold - 1)
for i in range(total_time_steps - 1, -1, -1):
opt_price = None
opt_price_value = None
for price in np.arange(0.0, 2.01, 0.10):
p_t = chance_to_sell(price)
reward_sold = (price - 1)
value = p_t * reward_sold + (1 - p_t) * values[i + 1]
if (opt_price_value is None) or (opt_price_value < value):
opt_price_value = value
opt_price = price
values[i] = opt_price_value
optimal_prices[i] = opt_price
return {'optimal_prices': optimal_prices,
'values': values}
def get_chance(x):
"""
Get probability that a banana will be sold at a given price x.
Parameters
----------
x : float
Returns
-------
chance_to_sell : float
"""
return (1 + math.exp(1)) / (1. + math.exp(x + 1))
if __name__ == '__main__':
total_time_steps = 2
main(total_time_steps=total_time_steps,
price_not_sold=0.0,
chance_to_sell=get_chance)
以下 DQN 代理(使用 Keras-RL 实现)适用于 CartPole-v0
环境,但会学习策略
1: Take action 19 (price= 1.90)
0: Take action 14 (price= 1.40)
用于 Banana 环境。它朝着正确的方向前进,但它始终学习该策略而不是不是最优策略:
为什么 DQN 智能体不学习最优策略?
执行:
$ python dqn.py --env Banana-v0 --steps 50000
dqn.py
的代码:
#!/usr/bin/env python
import numpy as np
import gym
import gym_banana
from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten
from keras.optimizers import Adam
from rl.agents.dqn import DQNAgent
from rl.policy import LinearAnnealedPolicy, EpsGreedyQPolicy
from rl.memory import EpisodeParameterMemory
def main(env_name, nb_steps):
# Get the environment and extract the number of actions.
env = gym.make(env_name)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n
input_shape = (1,) + env.observation_space.shape
model = create_nn_model(input_shape, nb_actions)
# Finally, we configure and compile our agent.
memory = EpisodeParameterMemory(limit=2000, window_length=1)
policy = LinearAnnealedPolicy(EpsGreedyQPolicy(), attr='eps', value_max=1.,
value_min=.1, value_test=.05,
nb_steps=1000000)
agent = DQNAgent(model=model, nb_actions=nb_actions, policy=policy,
memory=memory, nb_steps_warmup=50000,
gamma=.99, target_model_update=10000,
train_interval=4, delta_clip=1.)
agent.compile(Adam(lr=.00025), metrics=['mae'])
agent.fit(env, nb_steps=nb_steps, visualize=False, verbose=1)
# Get the learned policy and print it
policy = get_policy(agent, env)
for remaining_time, action in sorted(policy.items(), reverse=True):
print("{:>2}: Take action {:>2} (price={:>5.2f})"
.format(remaining_time, action, 2 / 20. * action))
def create_nn_model(input_shape, nb_actions):
"""
Create a neural network model which maps the input to actions.
Parameters
----------
input_shape : tuple of int
nb_actoins : int
Returns
-------
model : keras Model object
"""
model = Sequential()
model.add(Flatten(input_shape=input_shape))
model.add(Dense(32, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(nb_actions, activation='linear')) # important to be linear
print(model.summary())
return model
def get_policy(agent, env):
policy = {}
for x_in in range(env.TOTAL_TIME_STEPS):
action = agent.forward(np.array([x_in]))
policy[x_in] = action
return policy
def get_parser():
"""Get parser object for script xy.py."""
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
parser = ArgumentParser(description=__doc__,
formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument("--env",
dest="environment",
help="OpenAI Gym environment",
metavar="ENVIRONMENT",
default="CartPole-v0")
parser.add_argument("--steps",
dest="steps",
default=10000,
type=int,
help="how steps are trained?")
return parser
if __name__ == "__main__":
args = get_parser().parse_args()
main(args.environment, args.steps)
最佳答案
如果我正确地解释了您的代码,在我看来您正在使用 50K 训练步骤:
$ python dqn.py --env Banana-v0 --steps 50000
但也有一个 50K 步的预热期,方法是将以下内容放入 DQNAgent 构造函数中:
nb_steps_warmup=50000
我相信这意味着您实际上根本没有进行任何训练,因为热身期仅用于在回放缓冲区中收集经验,对吗?如果是这样,解决方案可能就像减少热身步骤数或增加训练步骤数一样简单。
为了将来引用(或者以防万一我对上面代码的解释有误),我建议始终创建一个学习曲线图(y 轴为剧集奖励,x 轴为训练步骤)。这对于了解正在发生的事情总是很有用,并且可以帮助您专注于调试代码的重要部分。如果奖励根本没有增加,您就会知道它出于某种原因根本没有学习。如果它们确实增加了一段时间,但随后趋于稳定,您可以尝试降低学习率。如果它们确实增加并一直增加到最后,您知道它可能还没有收敛,您可以尝试增加训练步数或增加学习率。
关于python - 为什么我的 DQN 代理无法在非确定性环境中找到最优策略?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/47259715/
我正在尝试使用 keras 在 Python 中编写自己的 DQN。我认为我的逻辑是正确的。我正在 CartPole 环境中尝试,但奖励在 50,000 集后并没有增加。任何帮助将不胜感激。目前我不关
我一直在尝试使用本文中的 DQN 解决 OpenAI 登月游戏 https://arxiv.org/pdf/2006.04938v2.pdf 问题是训练 50 集需要 12 个小时,所以一定是出了什么
我有一个或多或少标准的 DQN 实现来解决 Atari“Breakout”(来自 Coursera 强化学习类(class)),它在不同的计算机上表现完全不同: 在我的笔记本电脑上它收敛每次我运行它
QLearning方法有着明显的局限性,当状态和动作空间是离散的且维数不高时可使用Q-Table存储每个状态动作的Q值,而当状态和动作时高维连续时,该方法便不太适用。可以将Q-Table的更新问题变
对于强化学习,我读到张量板并不理想,因为它提供了每集和/或步骤的输入。由于强化学习有数千个步骤,因此它并没有给我们内容的概述。我在这里看到了这个修改后的张量板类:https://pythonprogr
对于强化学习,我读到张量板并不理想,因为它提供了每集和/或步骤的输入。由于强化学习有数千个步骤,因此它并没有给我们内容的概述。我在这里看到了这个修改后的张量板类:https://pythonprogr
我创建了一个深度 Q 网络来玩贪吃蛇。该代码运行良好,但在训练周期中性能并未真正提高。最后,它与采取随机操作的代理几乎没有区别。这是训练代码: def train(self): sel
编辑:以下似乎也是 FrozenLake-v0 的情况.请注意,我对简单的 Q 学习不感兴趣,因为我想看到适用于连续观察空间的解决方案。 我最近创建了 banana_gym OpenAI 环境。场景如
我正在使用 DQN 算法在我的环境中训练代理,如下所示: 代理通过选择离散 Action (左、右、上、下)来控制汽车 目标是以理想的速度行驶而不会撞到其他汽车 状态包含代理的汽车和周围汽车的速度和位
我正在实现简单的 DQN算法使用 pytorch , 解决来自 gym 的 CartPole 环境.我已经调试了一段时间,我无法弄清楚为什么模型没有学习。 观察: 使用 SmoothL1Loss性能比
我正在尝试构建一个可以学习玩游戏的深度 Q 网络 (DQN) 代理 2048 。我正在关注基于蛇游戏的其他程序和文章,并且效果很好( specifically this one )。 作为输入状态,我
我的任务涉及大型网格世界类型的环境(网格大小可能为 30x30、50x50、100x100,最大为 200x200)。该网格中的每个元素包含 0 或 1,它们在每个情节中随机初始化。我的目标是训练一个
我正在改编 Tabor 的 DQN 类(class) (https://github.com/philtabor/Deep-Q-Learning-Paper-To-Code) 中的 Pytorch 代
我正在使用 keras 构建 DQN,并使用具有经验回放内存的经典 DQN 算法对其进行训练。由于在 dqn 中,您需要多次调用 model.fit,这意味着每次从重播内存中采样批量数据时,使用 ke
我正在改编 Tabor 的 DQN 类(class) (https://github.com/philtabor/Deep-Q-Learning-Paper-To-Code) 中的 Pytorch 代
鉴于 OpenAI Gym 环境 MountainCar-v0总是返回 -1.0 作为奖励(即使目标实现了),我不明白 DQN 与经验回放如何收敛,但我知道它会收敛,因为我有 working code
我正在训练 DQN 来玩 OpenAI 的 Atari 环境,但我的网络的 Q 值迅速爆炸,远高于现实水平。 这是代码的相关部分: for state, action, reward, next_st
我最近开始研究神经网络。我目前正在试验 DQN。我已经能够让他们使用大量的 Atari 教程,但发现我无法理解整个问题,所以我为 DQN 编写了一个简单的模式来处理它只是 A 比 B 大,如果不是,则
您好,我正在尝试训练 DQN 来解决健身房的 Cartpole 问题。出于某种原因 Loss看起来像这样(橙色线)。你们能看看我的代码并帮助解决这个问题吗?我对超参数进行了一些尝试,所以我认为它们不是
所以我一直在关注 DQN 代理示例/教程,并按照示例中的方式进行设置,唯一的区别是我构建了自己的自定义 python 环境,然后将其包装在 TensorFlow 中。然而,无论我如何塑造我的观察和行动
我是一名优秀的程序员,十分优秀!