Question

我尝试熟悉Q-learning和Deep Neural Networks，目前尝试实施Playing Atari with Deep Reinforcement Learning。

为了测试我的实现并玩弄它，我试着尝试一个简单的gridworld。我有一个N x N网格，从左上角开始，在右下角结束。可能的操作是：向左，向上，向右，向下。

即使我的实现与this非常相似（希望它是一个好的），它似乎也没有学到任何东西。看看它需要完成的总步数（我猜平均值将达到500，网格大小为10x10，但也有非常低和高的值），它对我来说比其他任何东西都更随机。

我尝试使用和不使用卷积层并使用所有参数进行操作但说实话，我不知道我的实现是否有问题或者需要更长时间训练（我让它训练了很长时间））管他呢。但至少它接近收敛，这里是一个训练课程的损失值图：

那么这种情况下的问题是什么？

但是也可能更重要的是我如何“调试”这个Deep-Q-Nets，在监督培训中有训练，测试和验证集，例如精确和召回，可以评估它们。对于使用Deep-Q-Nets进行无监督学习，我有哪些选择，以便下次我可以自己修复它？

最后这是代码：

这是网络：

ACTIONS = 5

# Inputs
x = tf.placeholder('float', shape=[None, 10, 10, 4])
y = tf.placeholder('float', shape=[None])
a = tf.placeholder('float', shape=[None, ACTIONS])

# Layer 1 Conv1 - input
with tf.name_scope('Layer1'):
    W_conv1 = weight_variable([8,8,4,8])
    b_conv1 = bias_variable([8])    
    h_conv1 = tf.nn.relu(conv2d(x, W_conv1, 5)+b_conv1)

# Layer 2 Conv2 - hidden1 
with tf.name_scope('Layer2'):
    W_conv2 = weight_variable([2,2,8,8])
    b_conv2 = bias_variable([8])
    h_conv2 = tf.nn.relu(conv2d(h_conv1, W_conv2, 1)+b_conv2)
    h_conv2_max_pool = max_pool_2x2(h_conv2)

# Layer 3 fc1 - hidden 2
with tf.name_scope('Layer3'):
    W_fc1 = weight_variable([8, 32])
    b_fc1 = bias_variable([32])
    h_conv2_flat = tf.reshape(h_conv2_max_pool, [-1, 8])
    h_fc1 = tf.nn.relu(tf.matmul(h_conv2_flat, W_fc1)+b_fc1)

# Layer 4 fc2 - readout
with tf.name_scope('Layer4'):
    W_fc2 = weight_variable([32, ACTIONS])
    b_fc2 = bias_variable([ACTIONS])
    readout = tf.matmul(h_fc1, W_fc2)+ b_fc2

# Training
with tf.name_scope('training'):
    readout_action = tf.reduce_sum(tf.mul(readout, a), reduction_indices=1)
    loss = tf.reduce_mean(tf.square(y - readout_action))
    train = tf.train.AdamOptimizer(1e-6).minimize(loss)

    loss_summ = tf.scalar_summary('loss', loss)

这里的培训：

# 0 => left
# 1 => up
# 2 => right
# 3 => down
# 4 = noop

ACTIONS = 5
GAMMA = 0.95
BATCH = 50
TRANSITIONS = 2000
OBSERVATIONS = 1000
MAXSTEPS = 1000

D = deque()
epsilon = 1

average = 0
for episode in xrange(1000):
    step_count = 0
    game_ended = False

    state = np.array([0.0]*100, float).reshape(100)
    state[0] = 1

    rsh_state = state.reshape(10,10)
    s = np.stack((rsh_state, rsh_state, rsh_state, rsh_state), axis=2)

    while step_count < MAXSTEPS and not game_ended:
        reward = 0
        step_count += 1

        read = readout.eval(feed_dict={x: [s]})[0]

        act = np.zeros(ACTIONS)
        action = random.randint(0,4)
        if len(D) > OBSERVATIONS and random.random() > epsilon:
            action = np.argmax(read)
        act[action] = 1

        # play the game
        pos_idx = state.argmax(axis=0)
        pos = pos_idx + 1

        state[pos_idx] = 0
        if action == 0 and pos%10 != 1: #left
            state[pos_idx-1] = 1
        elif action == 1 and pos > 10: #up
            state[pos_idx-10] = 1
        elif action == 2 and pos%10 != 0: #right
            state[pos_idx+1] = 1
        elif action == 3 and pos < 91: #down
            state[pos_idx+10] = 1
        else: #noop
            state[pos_idx] = 1
            pass

        if state.argmax(axis=0) == pos_idx and reward > 0:
            reward -= 0.0001

        if step_count == MAXSTEPS:
            reward -= 100
        elif state[99] == 1: # reward & finished
            reward += 100
            game_ended = True
        else:
            reward -= 1


        s_old = np.copy(s)
        s = np.append(s[:,:,1:], state.reshape(10,10,1), axis=2)

        D.append((s_old, act, reward, s))
        if len(D) > TRANSITIONS:
            D.popleft()

        if len(D) > OBSERVATIONS:
            minibatch = random.sample(D, BATCH)

            s_j_batch = [d[0] for d in minibatch]
            a_batch = [d[1] for d in minibatch]
            r_batch = [d[2] for d in minibatch]
            s_j1_batch = [d[3] for d in minibatch]

            readout_j1_batch = readout.eval(feed_dict={x:s_j1_batch})
            y_batch = []

            for i in xrange(0, len(minibatch)):
                y_batch.append(r_batch[i] + GAMMA * np.max(readout_j1_batch[i]))

            train.run(feed_dict={x: s_j_batch, y: y_batch, a: a_batch})

        if epsilon > 0.05:
            epsilon -= 0.01

我感谢你们的每一个帮助和想法！

Answer 1

对于那些感兴趣的人，我进一步调整了参数和模型，但最大的改进是切换到一个简单的前馈网络，在隐藏层中有3层和大约50个神经元。对我而言，它会在相当不错的时间内融合。

对于调试程序的进一步提示表示赞赏！

Answer 2

所以很久以前，我写了这个问题，但是它仍然有一些兴趣和对运行代码的请求我最终决定创建一个github存储库

因为它是很久以前我写的等等它不会开箱即用，但它应该不是那么难以运行。所以这里是深度q网络和当时我写的例子，当时有效，希望你喜欢：Link to deep q repository

很高兴看到一些贡献，如果你修复它并让它运行发出拉动请求！

Answer 3

我实现了一个没有CNN层的简单玩具DQN，它可以工作。这是我实施过程中的一些发现，希望对您有所帮助。

根据DeepMind的论文，他们没有使用最大池化层，原因是图像将变为位置不变，这对游戏不利。代理人的位置对于游戏的信息至关重要。 DQN Architecture
如果您想跳过CNN首次使用的体育馆环境（就像我为玩具实现所做的一样），在开发过程中，我发现了以下几点：
- 通过一键式编码对环境状态进行编码，可以提高训练效率。

这是我发现对实现工作至关重要的两件事，我尚不完全了解其背后的原因，希望我的回答可以为您提供一些见识。

为什么我的Deep Q Network不能掌握简单的Gridworld（Tensorflow）？（如何评估Deep-Q-Net）

3 个答案:

为什么我的Deep Q Network不能掌握简单的Gridworld（Tensorflow）？ （如何评估Deep-Q-Net）

3 个答案:

为什么我的Deep Q Network不能掌握简单的Gridworld（Tensorflow）？（如何评估Deep-Q-Net）