标签: reinforcement-learning

我正在用Java编写辅助学习算法.

我遇到了一个我可以解决的数学问题,但由于处理过程很重,我需要一个最佳解决方案.

话虽这么说,如果有人知道一个非常棒的优化库,但语言是Java所以需要考虑.

这个想法很简单:

对象将存储变量的组合,例如ABDC,ACDE,DE,AE.

组合的最大数量将取决于我可以在不减慢程序速度的情况下运行的数量,因此理论上可以说100.

决策过程将每次迭代生成一个随机变量.如果生成的变量是其中一个组合的一部分,例如.'A'是ABDC和ACDE的一部分,而不是C和B(或存储的组合中的任何后续字母)的倾向将增加.

为了使事情更加清晰,我们假设'A','B','C','D'和'E'是唯一可能的变量.事实是,会有更多像12或14,但这个最大值还取决于我可以处理多少没有滞后.

由于有五个可能的变量,它将为第一次迭代生成加权1/5随机滚动.如果该滚动结果为'A',则在下一次迭代中'B'和'C'现在将具有2/5倾向而不是1/5.

如果下一次迭代产生'B','D'倾向将增加到3/5.注意:关系是指数关系; 实际上,它不会是1/5,而是像10%那样略微提升,如果它达到序列中的第4个变量,它将滚雪球说50%.

现在,在Java中,我可以通过跟踪每个对象的所有存储组合来实现此功能.我在想通过在每次迭代中以小步骤分配跟踪过程,它不应该太慢.

另一种解决方案是绘制所有可能的组合及其潜在的倾向.这当然只需要一个搜索功能,但也会在计算所有可能性和存储在某个地方时出现问题,可能在文件中.

有人建议我应该使用Markov模型和/或库,尽管我对这种类型的数学并不太熟悉.

如何在Java中快速计算此过程？
.

示例>>>

只有一个序列ABC.

对于三个数字,机会开始相等所以它看起来像兰特(1,3)

如果A是结果,我们增加B的可能性,因为它是序列中的下一个字母.让我们说它加倍.

所以现在机会是:A = 1/4,C = 1/4,B = 2/4

该函数现在看起来像rand(1,4),其中3和4的结果都代表选项B.

如果下一个结果是B,我们希望增加C的可能性,因为它是序列中的下一个字符,但是它是上次增加的两倍(指数)

机会现在类似于:A = 1/6,C = 1/6,B = 4/6

该函数现在为rand(1/6),其中值3,4,5,6表示C.

我正在尝试在 PyTorch 中建立一个通用的强化学习框架，以利用所有利用 PyTorch DataSet 和 DataLoader 的高级实用程序，例如 Ignite 或 FastAI，但我遇到了动态特性的阻碍强化学习数据：

• 数据项是从代码生成的，而不是从文件读取，并且它们依赖于先前的操作和模型结果，因此每个 nextItem 调用都需要访问模型状态。
• 训练集的长度不固定，因此我需要动态批量大小以及动态总数据集大小。我的偏好是使用终止条件函数而不是数字。我“可能”可以通过填充来做到这一点，就像在 NLP 句子处理中一样，但这是一个真正的黑客。

到目前为止，我的 Google 和 StackOverflow 搜索结果毫无结果。这里有人知道使用 DataLoader 或 DataSet 进行强化学习的现有解决方案或解决方法吗？我讨厌失去对依赖于这些库的所有现有库的访问权限。

我创建了一个自定义的 openai 健身房环境，其中包含离散的动作空间和稍微复杂的状态空间。状态空间被定义为元组，因为它结合了一些连续的维度和其他离散的维度：

import gym
from gym import spaces

class CustomEnv(gym.Env):
    def __init__(self):
        self.action_space = spaces.Discrete(3)
        self.observation_space = spaces.Tuple((spaces.Discrete(16),
                                               spaces.Discrete(2),
                                               spaces.Box(0,20000,shape=(1,)),
                                               spaces.Box(0,1000,shape=(1,)))
    ...

我很幸运地使用 keras-rl（特别是 DQNAgent）训练​​了一个代理，但是 keras-rl 的支持不足且文档很少。对于可以处理此类观察空间的强化学习包有什么建议吗？目前看来 openai 基线和 stable-baselines 都无法处理它。

或者，是否有一种不同的方式可以定义我的状态空间，以便将我的环境适应这些定义更好的包之一？

我在自定义环境中训练了 Ray-RLlib PPOTrainer。如何评估特定州的政策？

完整示例：

from ray.rllib.agents.ppo import PPOTrainer
from cust_env.envs import CustEnv
from ray.tune.logger import pretty_print

ray.init()
config = ppo.DEFAULT_CONFIG.copy()
config["num_workers"] = 2
config["eager"] = False
config["output"] = 'tmp/debug/'
trainer = PPOTrainer(config=config, env=TravelEnv)

# Can optionally call trainer.restore(path) to load a checkpoint.

for i in range(101):

   result = trainer.train()

   if i % 10 == 0:
       print(pretty_print(result))

有没有一种方法，如下所示，我可以在给定状态下返回最佳操作？

policy = trainer.get_policy()
optimal_action_at_state_S = policy.get_optimal_action(S)

该函数policy.compute_actions( )似乎从随机策略中返回随机样本，而不是最优操作。

我正在从事A2C强化学习，我的环境中代理的数量在增加和减少。由于代理数量的增加和减少，状态空间也会发生变化。我试图通过这种方式解决改变状态空间的问题：

• 如果状态空间超过选择为 的最大状态空间，则将选择n_input多余的状态空间， np.random.choice其中随机选择提供了一种在将状态空间转换为概率后从状态空间创建随机样本的方法。

• 如果状态空间小于最大状态，我用零填充状态空间。

  def get_state_new(state):
   n_features =  n_input-len(get_state(env))
   # print("state",len(get_state(env)))
   p = np.array(state)
   p = np.exp(p)
   if p.sum() != 1.0:
       p = p * (1. / p.sum())
   if len(get_state(env)) > n_input:
       statappend = np.random.choice(state, size=n_input, p=p)
       # print(statappend)
   else:
       statappend = np.zeros(n_input)
       statappend[:state.shape[0]] = state
   return statappend
  

  Run Code Online (Sandbox Code Playgroud)

它有效，但结果不如预期，我不知道这是否正确。

我的问题

有没有参考论文处理这样的问题以及如何处理状态空间的变化？

我在 Tkinter 中构建了环境，如何使用该环境创建观察空间。我无法理解如何使用数组中的网格坐标来制作观察空间， self.observation_space = space.Box(np.array([]), np.array([]), dtype=np.int)，给出了代码。如果有人提供帮助，我将不胜感激。

enter code here

# Setting the sizes for the environment
pixels = 40   # pixels
env_height =9   # grid height
env_width = 9  # grid width

# Global variable for dictionary with coordinates for the final route
a = {}


# Creating class for the environment
class Environment(tk.Tk, object):
def __init__(self):
    super(Environment, self).__init__()
    self.action_space = ['up', 'down', 'left', 'right']
    self.n_actions = len(self.action_space)
    self.title('RL Q-learning. Sichkar Valentyn')
    self.geometry('{0}x{1}'.format(env_height * pixels, env_height * pixels)) …

我正在尝试使用 StablesBaselines3 的 A2C 在我的自定义环境中训练代理。我的问题是，我的 GPU 利用率非常低（仅 10% 左右），而我的 CPU 利用率已达到上限。因此，训练速度非常非常慢。我已经按照 @araffin [https://github.com/hill-a/stable-baselines/issues/308] 提出的讨论主题尝试了以下操作

• 将 Actor 和 Critic 架构扩展为分别具有 256、256 和 128 个神经元的三层神经网络。此后 GPU 利用率确实有所增加，但只是微乎其微（从 10% 增加到 15%），如本建议所示
• device将A2C 方法的参数cuda从默认值“ ”更改为“ auto” - 没有改进

在上述讨论中，尚不完全清楚什么对用户有效。我的A2C初始化如下：

import gym
from stable_baselines3 import A2C
policy_kwargs = dict(activation_fn=th.nn.ReLU,
                     net_arch=[dict(pi=[256, 256, 128], vf=[256, 256, 128])])
model = A2C("MlpPolicy", env, verbose=1,  learning_rate=linear_schedule(0.001),\
 n_steps=50, gamma=0.8, gae_lambda=1.0, ent_coef=0.2, vf_coef=0.2, \
tensorboard_log=logdir,  policy_kwargs=policy_kwargs, seed=50, device='cuda' )
model.learn(total_timesteps=50000)

GPU 配置为：

• Cuda 版本 - 9.0
• GPU - …

我正在使用 实现简单的DQN算法pytorch来解决来自 的 CartPole 环境gym。我已经调试了一段时间了，我不明白为什么模型没有学习。

观察结果：

• 使用 的SmoothL1Loss性能比 差MSEloss，但两者的损失都会增加
• 较小的LR不起作用Adam，我已经使用 0.0001、0.00025、0.0005 和默认值进行了测试

笔记：

• 我已经单独调试了算法的各个部分，并且可以很有信心地说问题出在函数中learn。我想知道这个错误是否是由于我对detachpytorch 的误解或我犯的一些其他框架错误造成的。
• 我试图尽可能接近原始论文（上面链接）

参考：

• 示例：GitHub 要点
• 示例：pytroch 官方

import torch as T
import torch.nn as nn
import torch.nn.functional as F

import gym
import numpy as np


class ReplayBuffer:
    def __init__(self, mem_size, input_shape, output_shape):
        self.mem_counter = 0
        self.mem_size = mem_size
        self.input_shape = input_shape

        self.actions = np.zeros(mem_size)
        self.states = …

我以 Stable Baselines 3 的多处理示例为例，一切都很好。 https://colab.research.google.com/github/Stable-Baselines-Team/rl-colab-notebooks/blob/sb3/multiprocessing_rl.ipynb#scrollTo=pUWGZp3i9wyf

多处理训练比 num_cpu=4 的单处理训练花费的时间大约少 3.6 倍。

但是，当我尝试使用 PPO 代替 A3C，使用 BipedalWalker-v3 代替 CartPole-v1 时，我发现多处理模式下的性能更差。我的问题是：我做错了什么？为什么速度比较慢？

我的代码是：

import gym
import time

from stable_baselines3 import PPO
from stable_baselines3 import A2C
from stable_baselines3.common.env_util import make_vec_env
from stable_baselines3.common.evaluation import evaluate_policy

env_name = "BipedalWalker-v3"
num_cpu = 4
n_timesteps = 10000

env = make_vec_env(env_name, n_envs=num_cpu)

model = PPO('MlpPolicy', env, verbose=0)

start_time = time.time()
model.learn(n_timesteps)
total_time_multi = time.time() - start_time
print(f"Took {total_time_multi:.2f}s for multiprocessed version - {n_timesteps / total_time_multi:.2f} FPS")


single_process_model = PPO('MlpPolicy', …

我写这篇文章是因为自从我使用 slurm 以来，我一直无法正确使用 ray。\n每当我使用命令时：

\n
• 射线初始化
\n
• trainer = A3CTrainer(env = \xe2\x80\x9cmy_env\xe2\x80\x9d) （我已经注册了我的环境）
\n

，程序崩溃并显示以下消息：

core_worker.cc:137：无法将工作线程 01000000ffffffffffffffffffffffffffffffffffffffffffffffff 注册到 Raylet。IOError: [RayletClient] 无法向 raylet 注册工作线程。没有这样的文件或目录

该程序在我的计算机上运行良好，但在使用 Slurm 时出现了问题。我只要求 slurm 提供一台 GPU。

感谢您阅读我的文章并可能回答我的问题。\n祝您有美好的一天

关于代码的一些精度

@Alex\n我使用了以下代码：

import ray\nfrom ray.rllib.agents.a3c import A3CTrainer\nimport tensorflow as tf\nfrom MM1c_queue_env import my_env #my_env is already registered in tune\n\nray.shutdown()\nray.init(ignore_reinit_error=True)\ntrainer = A3CTrainer(env = "my_env")\n\nprint("success")\n

带有 trainer 和 init 的两条线都会导致程序崩溃，并出现我之前评论中提到的错误。要使用 slurm 启动该程序，我使用以下程序：

#!/bin/bash\n\n#SBATCH --job-name=rl_for_insensitive_policies\n#SBATCH --time=0:05:00 \n#SBATCH --ntasks=1\n#SBATCH --gres=gpu:1\n#SBATCH --partition=gpu\n\nmodule load anaconda3/2020.02/gcc-9.2.0\npython test.py\n …