标签: reinforcement-learning

• 我打算在我的项目中使用强化学习,但我不知道如何实现它.
• 所以我正在寻找一个具有不同RL算法的库,我可以在我的C#项目中使用它.

谢谢

请注意:我发现神经网络的NeuronDotNet库,我现在正在寻找RL库..

编辑:或Dot NET库

最近我研究了强化学习,有一个问题困扰着我,我无法找到答案:如何使用GPU有效地完成培训？据我所知,需要与环境保持持续的交互,这对我来说似乎是一个巨大的瓶颈,因为这个任务通常是非数学/不可并行化的.然而,例如Alpha Go使用多个TPU/GPU.那么他们是怎么做到的呢？

我创建了一个演员评论模型来测试一些OpenAI健身房环境.但是,我在某些环境中遇到问题.

CartPole:该模型最终收敛并获得最大奖励.但是,由于某些原因,如果我只使用策略梯度方法而不是值函数/优势,它会收敛得更快.

MountainCar,Acrobot:这两个型号都有负面奖励.如果你的经纪人需要10秒来解决任务,你的奖励将是-10.出于某种原因,当我试图解决负面回报的环境时,我的政策从负值开始并慢慢收敛到0.价值损失开始荒谬地高并且开始减少,尽管它在某个时候(当政策崩溃时)处于低位.任何人都可以帮我诊断问题吗？我添加了一些带有相关情节值的日志记录语句.

from scipy.signal import lfilter
import numpy as np
import gym
import tensorflow as tf

layers = tf.keras.layers

tf.enable_eager_execution()


def discount(x, gamma):
    return lfilter([1], [1, -gamma], x[::-1], axis=0)[::-1]


def boltzmann(probs):
    return tf.multinomial(tf.log(probs), 1)


def greedy(probs):
    return tf.argmax(probs)


def gae(bval, vals, rews):
    vboot = np.hstack((vals, bval))
    return rews * vboot[1:] - vals


class PG(tf.keras.Model):

    def __init__(self, n_actions, selection_strategy=boltzmann, lr=0.001):
        super(PG, self).__init__()
        self.fc1 = layers.Dense(64, activation='relu', kernel_initializer=tf.initializers.orthogonal(1))
        self.fc2 = layers.Dense(64, activation='relu', kernel_initializer=tf.initializers.orthogonal(1))
        self.pol = layers.Dense(n_actions, kernel_initializer=tf.initializers.orthogonal(0.01))
        self.val = layers.Dense(1, kernel_initializer=tf.initializers.orthogonal(1)) …

我正在研究一个旨在通过深度Q学习解决的问题。但是，问题在于，每个情节的培训时间都太长，大约需要83个小时。我们正在设想在100集之内解决问题。

因此，我们逐渐学习矩阵（100 * 10），并且在每个情节中，我们需要执行某些操作的100 * 10迭代。基本上，我们从1000个候选者的集合中选择一个候选者，将该候选者放入矩阵中，然后通过将整个矩阵作为输入来计算奖励函数：

中心的障碍是，每一步的奖励函数计算都非常昂贵，大约需要2分钟，并且每次我们更新矩阵中的一个条目时。

从长远来看，矩阵中的所有元素都是相互依赖的，因此，如果我理解正确的话，整个过程似乎不适合某些“分布式”系统。

有人可以阐明我们如何看待这里的潜在优化机会吗？喜欢一些额外的工程工作吗？任何建议和评论将不胜感激。谢谢。

========================更新了一些定义=================

0.初始阶段：

• 100 * 10矩阵，每个元素为空

1.动作空间：

• 每一步，我将从1000个元素的候选池中选择一个元素。然后将元素一一插入矩阵。

2.环境：

• 每一步我都会有一个更新的矩阵来学习。

• oracle函数F返回的定量值范围为5000〜30000，值越高越好（F的一次计算大约需要120秒）。

  此函数F将矩阵作为输入并执行非常昂贵的计算，并且返回一个定量值以指示到目前为止合成矩阵的质量。

  此函数本质上用于衡量系统的某些性能，因此确实需要一些时间才能在每个步骤中计算奖励值。

3.情节：

说“我们正在计划在100集内解决它”，这只是一个经验估计。但至少不应少于100集。

4.约束

理想的是，就像我提到的那样，“矩阵中的所有元素长期相互依赖”，这就是为什么奖励函数F通过将整个矩阵作为输入而不是最新选择的元素来计算奖励。

实际上，通过在矩阵中添加越来越多的元素，奖励可以增加，也可以减少。

5.目标

合成矩阵应使oracle函数F返回大于25000的值。只要达到此目标，我都会终止学习步骤。

我知道带有backprop的前馈多层神经网络与强化学习一起使用,以帮助它概括我们的代理所做的动作.这就是说,如果我们有一个大的状态空间,我们可以做一些动作,它们将有助于推广整个状态空间.

反复神经网络做了什么呢？一般来说,它们用于什么任务？

我正在尝试更改Karpathy的代码,以便它与softmax函数一起使用,以便我可以将它用于具有2个以上操作的游戏.但是,我无法让它发挥作用.有人可以帮我指出正确的方向吗？谢谢.以下是我的尝试.

""" Trains an agent with (stochastic) Policy Gradients on Pong. Uses OpenAI Gym. """
import numpy as np
import cPickle as pickle
import gym

# hyperparameters
H = 100 # number of hidden layer neurons
batch_size = 10 # every how many episodes to do a param update?
learning_rate = 1e-4
gamma = 0.9 # discount factor for reward
decay_rate = 0.9 # decay factor for RMSProp leaky sum of grad^2
resume = False # resume from previous checkpoint? …

在尝试创建神经网络并使用 Pytorch 对其进行优化时，我得到了

ValueError：优化器得到一个空的参数列表

这是代码。

import torch.nn as nn
import torch.nn.functional as F
from os.path import dirname
from os import getcwd
from os.path import realpath
from sys import argv

class NetActor(nn.Module):

    def __init__(self, args, state_vector_size, action_vector_size, hidden_layer_size_list):
        super(NetActor, self).__init__()
        self.args = args

        self.state_vector_size = state_vector_size
        self.action_vector_size = action_vector_size
        self.layer_sizes = hidden_layer_size_list
        self.layer_sizes.append(action_vector_size)

        self.nn_layers = []
        self._create_net()

    def _create_net(self):
        prev_layer_size = self.state_vector_size
        for next_layer_size in self.layer_sizes:
            next_layer = nn.Linear(prev_layer_size, next_layer_size)
            prev_layer_size = next_layer_size
            self.nn_layers.append(next_layer)

    def forward(self, torch_state):
        activations = torch_state
        for …

我正在阅读原始 PPO 论文并尝试将其与稳定基线 PPO2模型的输入参数相匹配。

我不明白的一件事是方法中的total_timesteps参数learn。

论文中提到

一种策略梯度实现方式……运行 T 个时间步长的策略（其中 T 远小于剧集长度）

虽然稳定基线文档将total_timesteps参数描述为

(int) 要训练的样本总数

因此，我认为T在论文和total_timesteps文档中是相同的参数。

我不明白的是：

• 是否total_timesteps总是需要小于或环境中的（说如果我有帧的数量有限喜欢1,000,000）等于可用“帧”（样本）的总数。如果是这样，为什么？

• 通过设置total_timesteps一个小于可用帧数的数字，代理会看到训练数据的哪一部分？例如，如果total_timesteps=1000，代理是否只看到前 1000 帧？

• 一集是定义为可用帧的总数，还是定义为代理第一次“松动”/“死亡”的时间？如果是后者，那么你怎么能提前知道代理什么时候会死才能设置total_timesteps一个较小的值呢？

我仍在学习 RL 背后的术语，所以我希望我能够在上面清楚地解释我的问题。非常欢迎任何帮助/提示。

使用Python3.6、Ubuntu 18.04、Gym 0.15.4、RoS melodic、Tensorflow 1.14 和 rl_coach 1.01：

我构建了一个自定义 Gym 环境，它使用 360 元素数组作为观察空间。

high = np.array([4.5] * 360) #360 degree scan to a max of 4.5 meters
low = np.array([0.0] * 360)
self.observation_space = spaces.Box(low, high, dtype=np.float32)

但是，这还不足以通过 ClippedPPO 算法进行正确训练，我想向我的状态添加其他功能，包括：

世界中的位置（x,y 坐标）
世界中的方向（四元数：x,y,z,w） 线性轨迹（x,y,z 坐标） 角轨迹（x,y,z 坐标）。

我将上面的四个特征放入自己的 np.arrays 中，并尝试将它们全部作为状态对象传递回来，但显然它与观察空间不匹配。space.Box 让我困惑。我假设我无法将所有这些功能转储到单个 np 数组中，因为上限和下限会有所不同，但是，我无法确定如何创建具有多个“功能”的 space.Box 对象。

TIA

在这里，他们提到需要optim.zero_grad()在训练时将参数梯度归零。我的问题是：我也可以这样做吗net.zero_grad()，会产生同样的效果吗？还是有必要做 optim.zero_grad()。此外，如果我两者都做会发生什么？如果我什么都不做，那么梯度就会累积，但这究竟是什么意思？他们会被添加吗？换句话说，doingoptim.zero_grad()和net.zero_grad(). 我问是因为在这里，他们使用第 115 行net.zero_grad()，这是我第一次看到，这是强化学习算法的实现，其中必须特别小心梯度，因为有多个网络和梯度，所以我假设他们有理由这样做net.zero_grad()而不是optim.zero_grad()。