标签: reinforcement-learning

我对 RL 很陌生，目前正在自学如何使用 tf_agents 库实现不同的算法和超参数。

我一直在使用本教程https://colab.research.google.com/github/tensorflow/agents/blob/master/docs/tutorials/1_dqn_tutorial.ipynb提供的代码。

在学习如何使用 TensorBoard 后，我开始想知道如何可视化 tf_agents 库中的图形。每个 TensorBoard 教程/帖子似乎都实现了自己的模型或定义 tf.function 来记录图。但是，我无法将此类方法应用于上面的教程。

如果有人可以帮助我在 TensorBoard 中使用 tf_agents 可视化模型图，我将非常感激。谢谢！

当我在 docker 中运行强化任务的 python 代码时，它无法呈现。当我收到导入错误时，我尝试安装 GL，但它仍然给我同样的错误。有没有其他方法可以解决这个问题而不干扰包管理器？

错误信息：

/usr/local/lib/python3.7/site-packages/gym/logger.py:30: UserWarning: WARN: Box bound precision lowered by casting to float32
warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))
Episode 0
Traceback (most recent call last):
File "/usr/local/lib/python3.7/site-packages/lbforaging/foraging/rendering.py", line 33, in <module>
  from pyglet.gl import *
File "/usr/local/lib/python3.7/site-packages/pyglet/gl/__init__.py", line 95, in <module>
  from pyglet.gl.lib import GLException
File "/usr/local/lib/python3.7/site-packages/pyglet/gl/lib.py", line 149, in <module>
  from pyglet.gl.lib_glx import link_GL, link_GLU, link_GLX
File "/usr/local/lib/python3.7/site-packages/pyglet/gl/lib_glx.py", line 45, in <module>
  gl_lib = pyglet.lib.load_library('GL')
File "/usr/local/lib/python3.7/site-packages/pyglet/lib.py", line 164, in load_library
  raise ImportError('Library …

我是 pytorch 的新手，我正在使用强化学习对时间序列进行 DQN 工作，我需要对时间序列和一些传感器读数进行复杂的观察，所以我合并了两个神经网络，我不确定这是否会破坏我的损失.向后或其他什么。我知道有多个具有相同标题的问题，但没有一个对我有用，也许我错过了一些东西。
首先，这是我的网络：

class DQN(nn.Module):
  def __init__(self, list_shape, score_shape, n_actions):
    super(DQN, self).__init__()

    self.FeatureList =  nn.Sequential(
            nn.Conv1d(list_shape[1], 32, kernel_size=8, stride=4),
            nn.ReLU(),
            nn.Conv1d(32, 64, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv1d(64, 64, kernel_size=3, stride=1),
            nn.ReLU(),
            nn.Flatten()
        )
    
    self.FeatureScore = nn.Sequential(
            nn.Linear(score_shape[1], 512),
            nn.ReLU(),
            nn.Linear(512, 128)
        )
    
    t_list_test = torch.zeros(list_shape)
    t_score_test = torch.zeros(score_shape)
    merge_shape = self.FeatureList(t_list_test).shape[1] + self.FeatureScore(t_score_test).shape[1]
    
    self.FinalNN =  nn.Sequential(
            nn.Linear(merge_shape, 512),
            nn.ReLU(),
            nn.Linear(512, 128),
            nn.ReLU(),
            nn.Linear(128, n_actions),
    )
    
  def forward(self, list, score):
    listOut = self.FeatureList(list)
    scoreOut = self.FeatureScore(score)
    MergedTensor = torch.cat((listOut,scoreOut),1) …

我在Tensorflow中使用了a3c实现的开源版本,这对于atari 2600实验非常有效.但是,当我修改Mujoco的网络时,如文中所述,网络拒绝学习任何有意义的东西.有没有人设法使a3c的任何开源实现与连续域问题一起工作,例如mujoco？

我试图对深度强化学习有一个直观的理解。在深度 Q 网络（DQN）中，我们将所有动作/环境/奖励存储在内存数组中，并在剧集结束时通过我们的神经网络“重播”它们。这是有道理的，因为我们正在尝试构建我们的奖励矩阵，看看我们的情节是否以奖励结束，然后通过我们的矩阵缩减奖励。

我认为导致奖励状态的动作序列是需要捕获的重要内容 - 这个动作序列（而不是独立的动作）是导致我们进入奖励状态的原因。

在Mnih 的 Atari-DQN 论文和许多教程中，我们看到了从内存阵列中随机采样和训练的实践。所以如果我们有这样的记忆：

（动作a，状态1）-->（动作b，状态2）-->（动作c，状态3）-->（动作d，状态4）-->奖励！

我们可以训练一小批：

[（动作c状态3），（动作b，状态2），奖励！]

给出的理由是：

其次，由于样本之间的相关性很强，直接从连续样本中学习效率很低；随机化样本会破坏这些相关性，从而减少更新的方差。

或者来自这个pytorch 教程：

通过随机采样，构建批次的转换是去相关的。事实证明，这极大地稳定并改进了 DQN 训练过程。

我的直觉告诉我，序列是强化学习中最重要的。大多数剧集都有延迟奖励，因此大多数行动/状态没有奖励（并且没有“强化”）。将部分奖励带到这些先前状态的唯一方法是追溯地将奖励分解到整个序列中（通过奖励 + 奖励 *learning_rate(future_reward)的 Q 算法中的 future_reward ）

内存库的随机采样打破了我们的序列，当您尝试回填 Q（奖励）矩阵时，这有什么帮助？

也许这更类似于马尔可夫模型，每个状态都应该被认为是独立的？我的直觉哪里出了问题？

谢谢你！

我正在尝试实现一个 DQN 算法，该算法通过在每个时间步提供游戏的 RAM 状态作为输入来训练代理从 Open AI Gym Atari 环境玩 Breakout。我使用了 jaara https://github.com/jaara/AI-blog/blob/master/Seaquest-DDQN-PER.py#L102的 AI-Blog 存储库中的代码并对其进行了一些更改。这是代码：

import random, numpy, math, gym
from SumTree import SumTree
import tensorflow as tf
import numpy as np
from tensorflow.keras import backend as K
import scipy.misc

# -----------------HYPER PARAMETERS--------------
# IMAGE_WIDTH = 84
# IMAGE_HEIGHT = 84
RAM_SIZE = 128
IMAGE_STACK = 2

HUBER_LOSS_DELTA = 2.0
LEARNING_RATE = 0.00025

MEMORY_CAPACITY = 200000

BATCH_SIZE = 32

GAMMA = 0.99

MAX_EPSILON = 1
MIN_EPSILON = 0.1

EXPLORATION_STOP …

我正在尝试为离散动作空间实现软演员评论家算法，但我在损失函数方面遇到了麻烦。

这是来自 SAC 的具有连续动作空间的链接：https : //spinningup.openai.com/en/latest/algorithms/sac.html

我不知道我做错了什么。

问题是网络在cartpole环境中没有学到任何东西。

github上的完整代码：https : //github.com/tk2232/sac_discrete/blob/master/sac_discrete.py

这是我的想法，如何计算离散动作的损失。

价值网络

class ValueNet:
    def __init__(self, sess, state_size, hidden_dim, name):
        self.sess = sess

        with tf.variable_scope(name):
            self.states = tf.placeholder(dtype=tf.float32, shape=[None, state_size], name='value_states')
            self.targets = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='value_targets')
            x = Dense(units=hidden_dim, activation='relu')(self.states)
            x = Dense(units=hidden_dim, activation='relu')(x)
            self.values = Dense(units=1, activation=None)(x)

            optimizer = tf.train.AdamOptimizer(0.001)

            loss = 0.5 * tf.reduce_mean((self.values - tf.stop_gradient(self.targets)) ** 2)
            self.train_op = optimizer.minimize(loss, var_list=_params(name))

    def get_value(self, s):
        return self.sess.run(self.values, feed_dict={self.states: s})

    def update(self, s, targets):
        self.sess.run(self.train_op, …

嗨，我正在尝试训练 DQN 来解决健身房的 Cartpole 问题。出于某种原因，损失看起来像这样（橙色线）。你们都可以看看我的代码并帮助解决这个问题吗？我已经对超参数进行了相当多的研究，所以我认为它们不是这里的问题。

class DQN(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(DQN, self).__init__()
        self.linear1 = nn.Linear(input_dim, 16)
        self.linear2 = nn.Linear(16, 32)
        self.linear3 = nn.Linear(32, 32)
        self.linear4 = nn.Linear(32, output_dim)


    def forward(self, x):
        x = F.relu(self.linear1(x))
        x = F.relu(self.linear2(x))
        x = F.relu(self.linear3(x))
        return self.linear4(x)


final_epsilon = 0.05
initial_epsilon = 1
epsilon_decay = 5000
global steps_done
steps_done = 0


def select_action(state):
    global steps_done
    sample = random.random()
    eps_threshold = final_epsilon + (initial_epsilon - final_epsilon) * \
                    math.exp(-1. * steps_done / epsilon_decay) …