标签: reinforcement-learning

我最近尝试在 Golang 中实现基本的 Q-Learning 算法。请注意，我对强化学习和人工智能总体来说是新手，所以这个错误很可能是我的。

以下是我如何在 m,n,k 游戏环境中实现该解决方案：\n在每个给定时间t，代理持有最后一个状态动作(s, a)及其获得的奖励；代理a'根据 Epsilon 贪婪策略选择移动并计算奖励r，然后继续更新Q(s, a)时间的值t-1

func (agent *RLAgent) learn(reward float64) {\n    var mState = marshallState(agent.prevState, agent.id)\n    var oldVal = agent.values[mState]\n\n    agent.values[mState] = oldVal + (agent.LearningRate *\n        (agent.prevScore + (agent.DiscountFactor * reward) - oldVal))\n}\n

笔记：

\n
• agent.prevState在采取行动之后和环境响应之前（即在代理移动之后和其他玩家移动之前）保持先前的状态我用它来代替状态动作元组，但我不太确定是否这是正确的做法
\n
• agent.prevScore保留对先前状态动作的奖励
\n
• 参数reward表示当前步骤的状态动作的奖励 ( Qmax)
\n

由于状态动作值溢出，代理无法达到 100K 集。\n我正在使用 golang 的agent.LearningRate = 0.2（标准 …

人们如何处理不同州的法律行动不同的问题？就我而言，我总共有大约 10 个诉讼，这些法律诉讼不重叠，这意味着在某些州，相同的 3 个州始终是合法的，而这些州在其他类型的州永远不合法。

我也有兴趣看看如果法律诉讼重叠，解决方案是否会有所不同。

对于 Q 学习（我的网络为我提供状态/动作对的值），我在想也许我可以在构建目标值时小心选择哪个 Q 值。（即我没有选择最大值，而是选择法律行动中的最大值......）

对于策略梯度类型的方法，我不太确定适当的设置是什么。计算损失时只屏蔽输出层可以吗？

我理解为什么机器学习如此命名，以及监督学习和无监督学习背后的术语。那么强化学习强化了什么？

今天在openai-gym环境下尝试实现一个rl-agent的时候，发现一个问题，好像所有的agent都是从最初始的状态开始训练的：env.reset()，即

import gym

env = gym.make("CartPole-v0")
initial_observation = env.reset()  # <-- Note
done = False

while not done:
    action = env.action_space.sample()  
    next_observation, reward, done, info = env.step(action)

env.close()  # close the environment

所以很自然地，代理可以沿着路线行事env.reset() -(action)-> next_state -(action)-> next_state -(action)-> ... -(action)-> done，这是一个插曲。但是，代理如何从特定状态（如中间状态）开始，然后从该状态采取行动？例如，我从重放缓冲区中采样了一个体验，即(s, a, r, ns, done)，如果我想训练代理直接从 state 开始，然后ns使用 a 获取动作Q-Network，然后n-step向前迈出一步，该怎么办。类似的东西：

import gym

env = gym.make("CartPole-v0")
initial_observation = ns  # not env.reset() 
done = False

while not done:
    action = …

我已经使用 DQN 算法训练了一个 RL 代理。在 20000 集之后，我的奖励收敛了。现在当我测试这个代理时，代理总是采取相同的行动，而不管状态如何。我觉得这很奇怪。有人可以帮我弄这个吗。有没有原因，谁能想到为什么agent会这样？

奖励情节

当我测试代理时

state = env.reset()
print('State: ', state)

state_encod = np.reshape(state, [1, state_size])
q_values = model.predict(state_encod)
action_key = np.argmax(q_values)
print(action_key)
print(index_to_action_mapping[action_key])
print(q_values[0][0])
print(q_values[0][action_key])

q_values_plotting = []
for i in range(0,action_size):
    q_values_plotting.append(q_values[0][i])


plt.plot(np.arange(0,action_size),q_values_plotting)

每次它都会给出相同的 q_values 图，即使每次初始化的状态都不同。 下面是 q_Value 图。

测试：

代码

test_rewards = []
for episode in range(1000):
    terminal_state = False
    state = env.reset()
    episode_reward = 0
    while terminal_state == False:
        print('State: ', state)
        state_encod = np.reshape(state, [1, state_size])
        q_values = model.predict(state_encod)
        action_key = …

我使用 LSTM 模型创建了一个词级文本生成器。但就我而言，并非每个词都适合选择。我希望它们匹配其他条件：

1. 每个单词都有一个映射：如果一个字符是元音，那么它会写 1，否则会写 0（例如，溢出是10100010）。然后，生成的句子需要满足给定的结构，例如，01001100（hi 01和朋友 001100）。
2. 最后一个单词的最后一个元音必须是提供的那个。假设是e。（周五ê次将做的工作，然后）。

因此，为了处理这种情况，我创建了一个具有以下结构的 Pandas 数据框：

word    last_vowel  word_map
-----   ---------   ----------
hello   o           01001
stack   a           00100
jhon    o           0010

这是我目前的工作流程：

1. 给定句子结构，我从数据框中选择一个与模式匹配的随机单词。例如，如果句子结构是0100100100100，我们可以选择单词hello，因为它的元音结构是01001。
2. 我从剩余的结构中减去选定的单词：0100100100100will be become00100100因为我们已经删除了首字母01001( hello )。
3. 我从与剩余结构的一部分匹配的数据帧中检索所有单词，在本例中为stack 00100和jhon 0010。
4. 我将当前单词句子内容（现在只是hello）传递给 LSTM 模型，它检索每个单词的权重。
5. 但我不只是想选择最佳选项，我想选择第 3 点选择中包含的最佳选项。所以我选择了该列表中估计值最高的单词，在本例中为stack。
6. 从第 …

我正在寻找tf-agents来了解强化学习。我正在关注本教程。使用了一种不同的策略，称为collect_policy培训而不是评估 ( policy)。

该教程指出存在差异，但在 IMO 中，它没有描述为什么有 2 个策略，因为它没有描述功能差异。

代理包含两个策略：

agent.policy — 用于评估和部署的主要策略。

agent.collect_policy — 用于数据收集的第二个策略。

我查看了 agent的源代码。它说

policy：tf_policy.Base代表代理当前策略的实例。

collect_policy：tf_policy.Base代表Agent当前数据采集策略的实例（用于设置self.step_spec）。

但是我self.step_spec在源文件中没有看到任何地方。我找到的下一个最接近的东西是time_step_spec. 但这是TFAgent该类的第一个 ctor 参数，因此通过collect_policy.

所以我唯一能想到的就是：把它付诸实践。所以我用policy代替collect_policy训练。尽管如此，代理还是达到了环境中的最高分数。

那么这两种策略之间的功能区别是什么？

我是强化学习的新手，我正在使用 RLlib 在 OpenAI 健身房中研究自定义环境的 RL。创建自定义环境时，是否需要在__init__()方法中指定剧集数？另外，当我用

for _ in range(10):
     trainer.train()

在一次迭代中采取了多少时间步？它是否等于自定义环境中定义的剧集数？谢谢你。

我正在尝试使用 TF-Agent TF-Agent DQN Tutorial训练强化学习代理。在我的应用程序中，我有 1 个动作，其中包含 9 个可能的离散值（标记为 0 到 8）。下面是输出env.action_spec()

BoundedTensorSpec(shape=(), dtype=tf.int64, name='action', minimum=array(0, dtype=int64), maximum=array(8, dtype=int64))

我想得到概率向量包含所有由训练策略计算的动作，并在其他应用环境中做进一步处理。但是，该策略仅返回log_probability一个值，而不是所有操作的向量。反正有没有得到概率向量？

from tf_agents.networks import q_network
from tf_agents.agents.dqn import dqn_agent

q_net = q_network.QNetwork(
            env.observation_spec(),
            env.action_spec(),
            fc_layer_params=(32,)
        )

optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate=0.001)

my_agent = dqn_agent.DqnAgent(
    env.time_step_spec(),
    env.action_spec(),
    q_network=q_net,
    epsilon_greedy=epsilon,
    optimizer=optimizer,
    emit_log_probability=True,
    td_errors_loss_fn=common.element_wise_squared_loss,
    train_step_counter=global_step)

my_agent.initialize()

...  # training

tf_policy_saver = policy_saver.PolicySaver(my_agent.policy)
tf_policy_saver.save('./policy_dir/')

# making decision using the trained policy
action_step = my_agent.policy.action(time_step)

在dqn_agent.DqnAgent() DQNAgent 中，我设置了emit_log_probability=True，它应该定义Whether policies …

我试图实现最简单的深度 Q 学习算法。我想，我已经正确地实施了它，并且知道深度 Q 学习在发散方面挣扎，但奖励下降得非常快，损失也在发散。如果有人能帮我指出正确的超参数，或者我是否错误地实施了算法，我将不胜感激。我尝试了很多超参数组合，也改变了 QNet 的复杂性。

import torch
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import collections
import numpy as np
import matplotlib.pyplot as plt
import gym
from torch.nn.modules.linear import Linear
from torch.nn.modules.loss import MSELoss


class ReplayBuffer:
  def __init__(self, max_replay_size, batch_size):
    self.max_replay_size = max_replay_size
    self.batch_size      = batch_size
    self.buffer          = collections.deque()


def push(self, *transition):
    if len(self.buffer) == self.max_replay_size:
        self.buffer.popleft()
    self.buffer.append(transition)


def sample_batch(self):
    indices = np.random.choice(len(self.buffer), self.batch_size, replace = False)
    batch   = [self.buffer[index] for index in …