深度强化学习(DRL 3) - 从Q-learning到Deep Q Network(DQN)

迷南。 2024-02-23 07:55 197阅读 0赞

目录

    • 一、Q-learning
    • 二、Deep Q Network
    • 三、Double DQN

一、Q-learning

关于Q-learning，网上的资料很多。

在这里插入图片描述

Q-learning最核心的是有一个Q表，它记录了在环境中的 所有状态(s) 以及每个状态可以进行的 所有行为(a) 的Q值，初值设为0。









































状态 \ 行为 a1 a2 a3 a4
s1
s2
s3
……

Q值的更新公式如下：

Q ( s , a ) ← Q ( s , a ) + α [ r + γ m a x a ′ Q ( s ′ , a ′ ) − Q ( s , a ) ] Q(s,a)←Q(s,a)+α[r+\gamma max_{a’}Q(s^′,a^′)−Q(s,a)] Q(s,a)←Q(s,a)+α[r+γmaxa′Q(s′,a′)−Q(s,a)]

  • 其中 α α α表示学习速率，取值小于1
  • r r r是设置的奖励
  • 智能体在状态s经过行为a转移到状态s’， m a x a ′ Q ( s ′ , a ′ ) max_{a’}Q(s^′,a^′) maxa′Q(s′,a′) 是状态 s ′ s’ s′ 那一行最大Q值
  • γ \gamma γ则是衰减速率，取值在0到1之间， γ \gamma γ越大，智能体就会越注重长期利益， γ \gamma γ越小，智能体越短视。

每改变一次状态就会更新一次Q值

Q-learning 是一个 off-policy 的算法，它可以离线学习。它可以随机进行若干次游戏，将游戏过程保存起来，学习的时候就可以避免陷入局部最优。

Q-learning 的代码实现：

  1. # -*- coding: UTF-8 -*-
  2. import numpy as np
  3. import pandas as pd
  6. class QLearningTable:
  7.     def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9):
  8.         self.actions = actions  # a list
  9.         self.lr = learning_rate
  10.         self.gamma = reward_decay
  11.         self.epsilon = e_greedy
  12.         self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)
  14.     def choose_action(self, observation):
  15.         self.check_state_exist(observation)
  16.         # action selection
  17.         if np.random.uniform() < self.epsilon:
  18.             # choose best action
  19.             state_action = self.q_table.loc[observation, :]
  20.             state_action = state_action.reindex(np.random.permutation(state_action.index))     # some actions have same value
  21.             action = state_action.idxmax()
  22.         else:
  23.             # choose random action
  24.             action = np.random.choice(self.actions)
  25.         return action
  27.     def learn(self, s, a, r, s_):
  28.         self.check_state_exist(s_)
  29.         q_predict = self.q_table.loc[s, a]
  30.         if s_ != 'terminal':
  31.             q_target = r + self.gamma * self.q_table.loc[s_, :].max()  # next state is not terminal
  32.         else:
  33.             q_target = r  # next state is terminal
  34.         self.q_table.loc[s, a] += self.lr * (q_target - q_predict)  # update
  36.     def check_state_exist(self, state):
  37.         if state not in self.q_table.index:
  38.             # append new state to q table
  39.             self.q_table = self.q_table.append(
  40.                 pd.Series(
  41.                     [0]*len(self.actions),
  42.                     index=self.q_table.columns,
  43.                     name=state,
  44.                 )
  45.             )

二、Deep Q Network

如果想用Q-learning玩之前的CartPole-v0游戏，会发现CartPole-v0的状态值太多了，它的observation有 车的位置，车的速度，杆子的角度，杆子顶端的速度 四个值，并且是连续的数值，四个值再进行量化，Q表实在是太大了。用Q-learning玩游戏和随机玩游戏没区别，学习不到东西。可能Q-learning只适用于走迷宫类的游戏，每一步的状态都可以很简单的描述出来，4*4的迷宫只需要用16个状态就可以全部囊括。

我们用Deep Q Network来解决这个问题， Deep Q Network融合了神经网络和 Q learning。

  • 我们可以将状态和动作当成神经网络的输入, 然后经过神经网络分析后得到动作的 Q 值, 这样我们就没必要在表格中记录 Q 值, 而是直接使用神经网络生成 Q 值.

  • 或者只输入状态值, 输出所有的动作值, 然后按照 Q learning 的原则, 直接选择拥有最大值的动作当做下一步要做的动作.

    在这里插入图片描述

需要搭建两个神经网络，target_net 和 eval_net ，
target_net 用于预测 q_target 值, 他不会及时更新参数.
target_net 用于预测 q_eval, 这个神经网络拥有最新的神经网络参数.

两个神经网络结构是完全一样的, 只是里面的参数不一样. target_net 是 eval_net 的一个历史版本, 拥有 eval_net 很久之前的一组参数, 而且这组参数被固定一段时间, 然后再被 eval_net 的新参数所替换. 而 eval_net 是不断在被提升的。这样做是为了打乱数据间的相关性，避免陷入局部最优。

神经网络的输入数据是[s,a,r,s’],输出数据是状态s下所有行为a的Q值。
target_net 只会输出Q值（q_target ），不会进行训练，而eval_net 输出Q值（q_eval）之后会根据q_target和q_eval进行反向传播训练，更新eval_net 的参数。

Deep Q Network整个算法的运作：

  1. 初始化target_net 和 target_net。
  2. 观察游戏状态observation，选择合适的observation作为输入，一般情况会对observation做数据处理，使其更容易训练，这里不用。
  3. 设置合适的奖励reward。
  4. 先进行若干次游戏，将游戏数据存储到memory中。
  5. 从memory中随机选取训练数据batch_memory用于批量训练。
  6. 训练eval_net 一段时间后，将eval_net 的参数复制给target_net 。
  7. 训练过程中产生的新的游戏数据会替代memory中的旧数据。

回到游戏CartPole-v0

DQN.py：

  1. import numpy as np
  2. import tensorflow as tf
  4. np.random.seed(1)
  5. tf.set_random_seed(1)
  8. # Deep Q Network off-policy
  9. class DeepQNetwork:
  10.     def __init__(
  11.             self,
  12.             n_actions,
  13.             n_features,
  14.             learning_rate=0.01,
  15.             reward_decay=0.9,
  16.             e_greedy=0.9,
  17.             replace_target_iter=300,
  18.             memory_size=500,
  19.             batch_size=32,
  20.             e_greedy_increment=None,
  21.             output_graph=True,
  22.     ):
  23.         self.n_actions = n_actions
  24.         self.n_features = n_features
  25.         self.lr = learning_rate
  26.         self.gamma = reward_decay
  27.         self.epsilon_max = e_greedy
  28.         self.replace_target_iter = replace_target_iter
  29.         self.memory_size = memory_size
  30.         self.batch_size = batch_size
  31.         self.epsilon_increment = e_greedy_increment
  32.         self.epsilon = 0 if e_greedy_increment is not None else self.epsilon_max
  34.         # total learning step
  35.         self.learn_step_counter = 0
  37.         # initialize zero memory [s, a, r, s_]
  38.         # [4, 1, 1, 4]
  39.         self.memory = np.zeros((self.memory_size, n_features * 2 + 2))
  41.         # consist of [target_net, evaluate_net]
  42.         self._build_net()
  44.         t_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='target_net')
  45.         e_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='eval_net')
  47.         with tf.variable_scope('hard_replacement'):
  48.             self.target_replace_op = [tf.assign(t, e) for t, e in zip(t_params, e_params)]
  50.         self.sess = tf.Session()
  52.         if output_graph:
  53.             # $ tensorboard --logdir=logs
  54.             tf.summary.FileWriter("logs/", self.sess.graph)
  56.         self.sess.run(tf.global_variables_initializer())
  57.         self.cost_his = []
  59.     def _build_net(self):
  60.         # ------------------ all inputs ------------------------
  61.         self.s = tf.placeholder(tf.float32, [None, self.n_features], name='s')  # input State
  62.         self.s_ = tf.placeholder(tf.float32, [None, self.n_features], name='s_')  # input Next State
  63.         self.r = tf.placeholder(tf.float32, [None, ], name='r')  # input Reward
  64.         self.a = tf.placeholder(tf.int32, [None, ], name='a')  # input Action
  66.         w_initializer, b_initializer = tf.random_normal_initializer(0., 0.3), tf.constant_initializer(0.1)
  68.         # ------------------ build evaluate_net ------------------
  69.         with tf.variable_scope('eval_net'):
  70.             e1 = tf.layers.dense(self.s, 20, tf.nn.relu, kernel_initializer=w_initializer,
  71.                                  bias_initializer=b_initializer, name='e1')
  72.             self.q_eval = tf.layers.dense(e1, self.n_actions, kernel_initializer=w_initializer,
  73.                                           bias_initializer=b_initializer, name='q')
  75.         # ------------------ build target_net ------------------
  76.         with tf.variable_scope('target_net'):
  77.             t1 = tf.layers.dense(self.s_, 20, tf.nn.relu, kernel_initializer=w_initializer,
  78.                                  bias_initializer=b_initializer, name='t1')
  79.             self.q_next = tf.layers.dense(t1, self.n_actions, kernel_initializer=w_initializer,
  80.                                           bias_initializer=b_initializer, name='t2')
  82.         with tf.variable_scope('q_target'):
  83.             q_target = self.r + self.gamma * tf.reduce_max(self.q_next, axis=1, name='Qmax_s_')  # shape=(None, )
  84.             self.q_target = tf.stop_gradient(q_target)
  85.         with tf.variable_scope('q_eval'):
  86.             a_indices = tf.stack([tf.range(tf.shape(self.a)[0], dtype=tf.int32), self.a], axis=1)
  87.             self.q_eval_wrt_a = tf.gather_nd(params=self.q_eval, indices=a_indices)  # shape=(None, )
  88.         with tf.variable_scope('loss'):
  89.             self.loss = tf.reduce_mean(tf.squared_difference(self.q_target, self.q_eval_wrt_a, name='TD_error'))
  90.         with tf.variable_scope('train'):
  91.             self._train_op = tf.train.RMSPropOptimizer(self.lr).minimize(self.loss)
  93.     def store_transition(self, s, a, r, s_):
  94.         if not hasattr(self, 'memory_counter'):
  95.             self.memory_counter = 0
  96.         transition = np.hstack((s, [a, r], s_))
  97.         # replace the old memory with new memory
  98.         index = self.memory_counter % self.memory_size
  99.         self.memory[index, :] = transition
  100.         self.memory_counter += 1
  102.     def choose_action(self, observation):
  103.         # to have batch dimension when feed into tf placeholder
  104.         observation = observation[np.newaxis, :]
  106.         if np.random.uniform() < self.epsilon:
  107.             # forward feed the observation and get q value for every actions
  108.             actions_value = self.sess.run(self.q_eval, feed_dict={ 
  109.    self.s: observation})
  110.             action = np.argmax(actions_value)
  111.         else:
  112.             action = np.random.randint(0, self.n_actions)
  113.         return action
  115.     def learn(self):
  116.         # check to replace target parameters
  117.         if self.learn_step_counter % self.replace_target_iter == 0:
  118.             self.sess.run(self.target_replace_op)
  119.             print('\ntarget_params_replaced\n')
  121.         # sample batch memory from all memory
  122.         if self.memory_counter > self.memory_size:
  123.             sample_index = np.random.choice(self.memory_size, size=self.batch_size)
  124.         else:
  125.             sample_index = np.random.choice(self.memory_counter, size=self.batch_size)
  126.         batch_memory = self.memory[sample_index, :]
  128.         _, cost = self.sess.run(
  129.             [self._train_op, self.loss],
  130.             feed_dict={ 
  132.                 self.s: batch_memory[:, :self.n_features],
  133.                 self.a: batch_memory[:, self.n_features],
  134.                 self.r: batch_memory[:, self.n_features + 1],
  135.                 self.s_: batch_memory[:, -self.n_features:],
  136.             })
  138.         self.cost_his.append(cost)
  140.         # increasing epsilon
  141.         self.epsilon = self.epsilon + self.epsilon_increment if self.epsilon < self.epsilon_max else self.epsilon_max
  142.         self.learn_step_counter += 1
  144.     def plot_cost(self):
  145.         import matplotlib.pyplot as plt
  146.         plt.plot(np.arange(len(self.cost_his)), self.cost_his)
  147.         plt.ylabel('Cost')
  148.         plt.xlabel('training steps')
  149.         plt.show()
  152. if __name__ == '__main__':
  153.     DQN = DeepQNetwork(3, 4, output_graph=True)

DQN_CarPole.py:

  1. import gym
  2. from DQN import DeepQNetwork
  4. env = gym.make('CartPole-v0')
  5. env = env.unwrapped
  6. RL = DeepQNetwork(n_actions=env.action_space.n,
  7.                   n_features=env.observation_space.shape[0],
  8.                   learning_rate=0.01, e_greedy=0.9,
  9.                   replace_target_iter=100, memory_size=2000,
  10.                   e_greedy_increment=0.0008, )
  11. total_steps = 0  # 记录步数
  13. for i_episode in range(100):
  15.     # 获取回合 i_episode 第一个 observation
  16.     observation = env.reset()
  17.     ep_r = 0
  18.     while True:
  19.         env.render()  # 刷新环境
  21.         action = RL.choose_action(observation)  # 选行为
  23.         observation_, reward, done, info = env.step(action)  # 获取下一个 state
  25.         x, x_dot, theta, theta_dot = observation_  # 细分开, 为了修改原配的 reward
  27.         # x 是车的水平位移, 所以 r1 是车越偏离中心, 分越少
  28.         # theta 是棒子离垂直的角度, 角度越大, 越不垂直. 所以 r2 是棒越垂直, 分越高
  29.         r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8
  30.         r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5
  31.         reward = r1 + r2  # 总 reward 是 r1 和 r2 的结合, 既考虑位置, 也考虑角度, 这样 DQN 学习更有效率
  33.         # 保存这一组记忆
  34.         RL.store_transition(observation, action, reward, observation_)
  36.         if total_steps > 1000:
  37.             RL.learn()  # 学习
  39.         ep_r += reward
  40.         if done:
  41.             print('episode: ', i_episode,
  42.                   'ep_r: ', round(ep_r, 2),
  43.                   ' epsilon: ', round(RL.epsilon, 2))
  44.             break
  46.         observation = observation_
  47.         total_steps += 1
  48. # 最后输出 cost 曲线
  49. RL.plot_cost()
  50. env.close()

运行DQN_CarPole.py
发现小车确实变得越来越稳定。

最后输出的损失函数曲线

在这里插入图片描述

三、Double DQN

无论是Q-learning还是DQN，更新Q值的的时候都会用到 m a x Q maxQ maxQ。

Q-learning:
Q ( s , a ) ← Q ( s , a ) + α [ r + γ m a x a ′ Q ( s ′ , a ′ ) − Q ( s , a ) ] Q(s,a)←Q(s,a)+α[r+\gamma max_{a’}Q(s^′,a^′)−Q(s,a)] Q(s,a)←Q(s,a)+α[r+γmaxa′Q(s′,a′)−Q(s,a)]

DQN:

在这里插入图片描述

使用max虽然可以快速让Q值向可能的优化目标靠拢，但是很容易过犹不及，导致过度估计(Over Estimation)，所谓过度估计就是最终我们得到的算法模型有很大的偏差(bias)，可能就会发现Q值都超级大。

DDQN通过解耦目标Q值动作的选择和目标Q值的计算这两步，来达到消除过度估计的问题。

在这里插入图片描述

DDQN更新：

在这里插入图片描述

在DDQN这里，不再是直接在目标Q网络里面找各个动作中最大Q值，而是先在当前Q网络中先找出最大Q值对应的动作。然后利用这个选择出来的动作在目标Q网络里面去计算目标Q值。

DoubleDQN.py

  1. import numpy as np
  2. import tensorflow as tf
  4. np.random.seed(1)
  5. tf.set_random_seed(1)
  8. class DoubleDQN:
  9.     def __init__(
  10.             self,
  11.             n_actions,
  12.             n_features,
  13.             learning_rate=0.005,
  14.             reward_decay=0.9,
  15.             e_greedy=0.9,
  16.             replace_target_iter=200,
  17.             memory_size=3000,
  18.             batch_size=32,
  19.             e_greedy_increment=None,
  20.             output_graph=False,
  21.     ):
  22.         self.n_actions = n_actions
  23.         self.n_features = n_features
  24.         self.lr = learning_rate
  25.         self.gamma = reward_decay
  26.         self.epsilon_max = e_greedy
  27.         self.replace_target_iter = replace_target_iter
  28.         self.memory_size = memory_size
  29.         self.batch_size = batch_size
  30.         self.epsilon_increment = e_greedy_increment
  31.         self.epsilon = 0 if e_greedy_increment is not None else self.epsilon_max
  32.         self.learn_step_counter = 0
  33.         self.memory = np.zeros((self.memory_size, n_features * 2 + 2))
  34.         self._build_net()
  35.         t_params = tf.get_collection('target_net_params')
  36.         e_params = tf.get_collection('eval_net_params')
  37.         self.replace_target_op = [tf.assign(t, e) for t, e in zip(t_params, e_params)]
  39.         self.sess = tf.Session()
  41.         if output_graph:
  42.             tf.summary.FileWriter("logs/", self.sess.graph)
  44.         self.sess.run(tf.global_variables_initializer())
  45.         self.cost_his = []
  47.     def _build_net(self):
  48.         def build_layers(s, c_names, n_l1, w_initializer, b_initializer):
  49.             with tf.variable_scope('l1'):
  50.                 w1 = tf.get_variable('w1', [self.n_features, n_l1], initializer=w_initializer, collections=c_names)
  51.                 b1 = tf.get_variable('b1', [1, n_l1], initializer=b_initializer, collections=c_names)
  52.                 l1 = tf.nn.relu(tf.matmul(s, w1) + b1)
  54.             with tf.variable_scope('l2'):
  55.                 w2 = tf.get_variable('w2', [n_l1, self.n_actions], initializer=w_initializer, collections=c_names)
  56.                 b2 = tf.get_variable('b2', [1, self.n_actions], initializer=b_initializer, collections=c_names)
  57.                 out = tf.matmul(l1, w2) + b2
  58.             return out
  60.         # ------------------ build evaluate_net ------------------
  61.         self.s = tf.placeholder(tf.float32, [None, self.n_features], name='s')  # input
  62.         self.q_target = tf.placeholder(tf.float32, [None, self.n_actions], name='Q_target')  # for calculating loss
  64.         with tf.variable_scope('eval_net'):
  65.             c_names, n_l1, w_initializer, b_initializer = \
  66.                 ['eval_net_params', tf.GraphKeys.GLOBAL_VARIABLES], 20, \
  67.                 tf.random_normal_initializer(0., 0.3), tf.constant_initializer(0.1)  # config of layers
  69.             self.q_eval = build_layers(self.s, c_names, n_l1, w_initializer, b_initializer)
  71.         with tf.variable_scope('loss'):
  72.             self.loss = tf.reduce_mean(tf.squared_difference(self.q_target, self.q_eval))
  73.         with tf.variable_scope('train'):
  74.             self._train_op = tf.train.RMSPropOptimizer(self.lr).minimize(self.loss)
  76.         # ------------------ build target_net ------------------
  77.         self.s_ = tf.placeholder(tf.float32, [None, self.n_features], name='s_')  # input
  78.         with tf.variable_scope('target_net'):
  79.             c_names = ['target_net_params', tf.GraphKeys.GLOBAL_VARIABLES]
  81.             self.q_next = build_layers(self.s_, c_names, n_l1, w_initializer, b_initializer)
  83.     def store_transition(self, s, a, r, s_):
  84.         if not hasattr(self, 'memory_counter'):
  85.             self.memory_counter = 0
  86.         transition = np.hstack((s, [a, r], s_))
  87.         index = self.memory_counter % self.memory_size
  88.         self.memory[index, :] = transition
  89.         self.memory_counter += 1
  91.     def choose_action(self, observation):
  92.         observation = observation[np.newaxis, :]
  93.         actions_value = self.sess.run(self.q_eval, feed_dict={ 
  94.    self.s: observation})
  95.         action = np.argmax(actions_value)
  97.         if not hasattr(self, 'q'):  # record action value it gets
  98.             self.q = []
  99.             self.running_q = 0
  100.         self.running_q = self.running_q * 0.99 + 0.01 * np.max(actions_value)
  101.         self.q.append(self.running_q)
  103.         if np.random.uniform() > self.epsilon:  # choosing action
  104.             action = np.random.randint(0, self.n_actions)
  105.         return action
  107.     def learn(self):
  108.         if self.learn_step_counter % self.replace_target_iter == 0:
  109.             self.sess.run(self.replace_target_op)
  110.             print('\ntarget_params_replaced\n')
  112.         if self.memory_counter > self.memory_size:
  113.             sample_index = np.random.choice(self.memory_size, size=self.batch_size)
  114.         else:
  115.             sample_index = np.random.choice(self.memory_counter, size=self.batch_size)
  116.         batch_memory = self.memory[sample_index, :]
  118.         q_next, q_eval4next = self.sess.run(
  119.             [self.q_next, self.q_eval],
  120.             feed_dict={ 
  121.    self.s_: batch_memory[:, -self.n_features:],  # next observation
  122.                        self.s: batch_memory[:, -self.n_features:]})  # next observation
  123.         q_eval = self.sess.run(self.q_eval, { 
  124.    self.s: batch_memory[:, :self.n_features]})
  126.         q_target = q_eval.copy()
  128.         batch_index = np.arange(self.batch_size, dtype=np.int32)
  129.         eval_act_index = batch_memory[:, self.n_features].astype(int)
  130.         reward = batch_memory[:, self.n_features + 1]
  132.         max_act4next = np.argmax(q_eval4next,
  133.                                  axis=1)  # the action that brings the highest value is evaluated by q_eval
  134.         selected_q_next = q_next[batch_index, max_act4next]  # Double DQN, select q_next depending on above actions
  136.         q_target[batch_index, eval_act_index] = reward + self.gamma * selected_q_next
  138.         _, self.cost = self.sess.run([self._train_op, self.loss],
  139.                                      feed_dict={ 
  140.    self.s: batch_memory[:, :self.n_features],
  141.                                                 self.q_target: q_target})
  142.         self.cost_his.append(self.cost)
  144.         self.epsilon = self.epsilon + self.epsilon_increment if self.epsilon < self.epsilon_max else self.epsilon_max
  145.         self.learn_step_counter += 1
  147.     def plot_cost(self):
  148.         import matplotlib.pyplot as plt
  149.         plt.plot(np.arange(len(self.cost_his)), self.cost_his)
  150.         plt.ylabel('Cost')
  151.         plt.xlabel('training steps')
  152.         plt.show()

DoubleDQN_CarPole.py

  1. import tensorflow as tf
  2. import gym
  3. from DoubleDQN import DoubleDQN
  5. env = gym.make('CartPole-v0')
  6. env = env.unwrapped
  8. double_DQN = DoubleDQN(n_actions=env.action_space.n,
  9.                        n_features=env.observation_space.shape[0],
  10.                        memory_size=2000,
  11.                        e_greedy_increment=0.001,
  12.                        output_graph=True)
  13. total_steps = 0  # 记录步数
  15. for i_episode in range(100):
  17.     # 获取回合 i_episode 第一个 observation
  18.     observation = env.reset()
  19.     ep_r = 0
  20.     while True:
  21.         env.render()  # 刷新环境
  23.         action = double_DQN.choose_action(observation)  # 选行为
  25.         observation_, reward, done, info = env.step(action)  # 获取下一个 state
  27.         x, x_dot, theta, theta_dot = observation_  # 细分开, 为了修改原配的 reward
  29.         # x 是车的水平位移, 所以 r1 是车越偏离中心, 分越少
  30.         # theta 是棒子离垂直的角度, 角度越大, 越不垂直. 所以 r2 是棒越垂直, 分越高
  31.         r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8
  32.         r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5
  33.         reward = r1 + r2  # 总 reward 是 r1 和 r2 的结合, 既考虑位置, 也考虑角度, 这样 DQN 学习更有效率
  35.         # 保存这一组记忆
  36.         double_DQN.store_transition(observation, action, reward, observation_)
  38.         if total_steps > 1000:
  39.             double_DQN.learn()  # 学习
  41.         ep_r += reward
  42.         if done:
  43.             print('episode: ', i_episode,
  44.                   'ep_r: ', round(ep_r, 2),
  45.                   ' epsilon: ', round(double_DQN.epsilon, 2))
  46.             break
  48.         observation = observation_
  49.         total_steps += 1
  50. # 最后输出 cost 曲线
  51. double_DQN.plot_cost()
  52. env.close()

输出损失函数结果

在这里插入图片描述

对比DQN，可以发现DoubleDQN效果明显好很多。

发表评论

表情：
评论列表 （有 0 条评论，197人围观）

还没有评论，来说两句吧...

相关阅读