标签: reinforcement-learning

我安装了 anaconda，但是当我运行 conda init 时不起作用，我使用 ssh 将其安装在远程 jetson nano（ARM 架构）上。

我已经为 Cartpole-VO 环境实现了 PPO。然而，它在游戏的某些迭代中并不收敛。有时它会陷入局部最优。我已经使用 TD-0 优势实现了该算法，即

A(s_t) = R(t+1) + \gamma V(S_{t+1}) - V(S_t)

这是我的代码：

def running_average(x, n):
    N = n
    kernel = np.ones(N)
    conv_len = x.shape[0]-N
    y = np.zeros(conv_len)
    for i in range(conv_len):
        y[i] = kernel @ x[i:i+N] # matrix multiplication operator: np.mul
        y[i] /= N
    return y



class ActorNetwork(nn.Module):
    def __init__(self, state_dim, n_actions, learning_rate=0.0003, epsilon_clipping=0.3, update_epochs=10):
        super().__init__()
        self.n_actions = n_actions
        self.model = nn.Sequential(
            nn.Linear(state_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, n_actions),
            nn.Softmax(dim=-1)
        ).float()
        self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
        self.epsilon_clipping …

我以 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 …

假设我们在一个我们的代理可以沿着xx和yy轴移动的房间里。在每个点他都可以上下左右移动。因此，我们的状态空间可以由（x，y）定义，而我们在每个点上的动作都可以由（上，下，右，左）给出。假设我们的特工在任何使他撞墙的行动中，我们都会给他-1的负数回报，并使他回到以前的状态。如果他在房间中央发现一个木偶，他将获得+10奖励。

当我们更新给定状态/动作对的QValue时，我们会看到在新状态下可以执行哪些动作，并计算出可能达到的最大QValue，因此我们可以更新Q（s，a）当前状态/动作的值。这意味着，如果我们在点（10，10）中有一个目标状态，则它周围的所有状态的QValue会随着距离的增加而越来越小。现在，在与墙壁的关系上，在我看来这是不正确的。

当业务代表撞墙时（假设他处于位置（0，0）并进行了动作UP），他将为该状态/动作获得-1的奖励，从而获得-1的QValue。

现在，如果稍后我处于状态（0，1），并假设状态（0,0 0）的所有其他动作均为零，则在为动作LEFT计算（0，1）的QValue时，它将计算它可以通过以下方式：

Q([0,1], LEFT) = 0 + gamma * (max { 0, 0, 0, -1 } ) = 0 + 0 = 0

这就是说，碰壁不会传播到附近的状态，这与您拥有积极奖励状态时发生的情况相反。

在我看来，这似乎很奇怪。起初，我认为找到给予负面奖励的状态/动作对与正面奖励一样是学习上的明智之举，但是从我上面显示的示例来看，这种说法似乎并不成立。在算法中似乎存在偏见，其要更多地考虑正面奖励而不是负面奖励。

这是QLearning的预期行为吗？不好的奖励不应该和积极的奖励一样重要吗？什么是“解决方法”？

我的一些实验室伙伴一直在研究交叉熵强化学习。从我可以从他们那里收集的所有信息以及快速的互联网搜索中，交叉熵方法似乎与遗传算法几乎相同。有人可以向我解释一下，如果一种技术确实存在，这两种技术之间的真正区别是什么？

我在Keras中有一个网络，其中有很多输出，但是，我的训练数据一次只能提供单个输出的信息。

目前，我的训练方法是对有问题的输入进行预测，更改我正在训练的特定输出的值，然后进行单批更新。如果我是对的，这与将所有输出的损失设置为零（除了我尝试训练的损失）相同。

有没有更好的办法？我尝试过权重设置，但我正在训练的所有输出都设置为零权重，但是没有给我期望的结果？

我正在使用Theano后端。

在Sutton&Barto的RL书(链接)中,Watkins的Q(λ)学习算法如图7.14所示: 第10行"对于所有s,a:",这里的"s,a"适用于所有(s,a),而第8行和第9行中的(s,a)用于当前(s,a) , 这是正确的吗？

在第12行和第13行中,当'!= a*,执行第13行时,所有e(s,a)都将设置为0,那么当所有资格跟踪都设置为0时,资格跟踪的点是什么,因为情况'!= a*会经常发生.即使情况'!= a*不经常发生,但一旦发生,资格跟踪的含义将完全失败,那么Q将不会再次更新,因为所有的e(s,a)= 0,然后在每次更新时,如果使用替换迹线,e(s,a)仍将为0.

那么,这是一个错误吗？

据我所知,NEAT(增强拓扑的NeuroEvolution)是一种使用进化概念训练神经网络的算法.另一方面,强化学习是一种机器学习,其概念是"奖励"更成功的节点.

这两个字段有什么区别,因为它们看起来非常相似？或者NEAT来自强化学习？

我正在尝试训练强化学习模型,以回应我使用的一个点keras-rl.

我的代码如下所示,使用20x20的世界形状.

import numpy as np
import rl.core as krl


class EchoEnv(krl.Env):

    def __init__(self):
        self.shape = np.array([20, 20])
        self.desired = np.random.rand(*self.shape.shape)

    def step(self, action):

        action = np.clip(action, 0, 1) * self.shape
        self.action = action

        observation = self.desired

        dx = action - (self.desired * self.shape)
        distance_to_goal = np.sqrt((dx**2).sum())

        done = distance_to_goal < 1

        reward = -distance_to_goal

        # observation, reward, done, info
        return observation, reward, done, {}

    def reset(self):
        self.desired = np.random.rand(*self.shape.shape)
        return self.desired

每次迭代,observation提供的是当前的随机self.desired值.(代理应该 …