强化学习（一）——基本概念及DQN

1 基本概念

• 智能体 agent ，做动作的主体，（大模型中的AI agent）

• 环境 environment：与智能体交互的对象

• 状态 state ；当前所处状态，如围棋棋局

• 动作 action：执行的动作，如围棋可落子点

• 奖励 reward：执行当前动作得到的奖励,(大模型中的奖励模型)

• 策略 policy: $\pi (a|s)$ 当前状态如何选择action,如当前棋局，落子每个点的策略

• 回报(累计奖励) return : 是从当前时刻开始到本回合结束的所有奖励的总和,$U_t=R_t+\gamma R_{t+1}+{\gamma }^{2}Rt+2+{\gamma }^{3}Rt+3....$

• 折扣回报 :

• 动作价值函数：$Q_{\pi }(s_t,a_t)=E[U_t|S_t=s_t,A_t=a_t]$

• 最优动作价值函数：$Q^{\ast }(s_t,a_t)=ma{x}_{\pi }{Q}_{\pi }(s_t,a_t)$

• 状态价值函数：$V_{\pi }(s_t)=E_A[Q_{\pi }(s_t,A)]$

2 DQN

折扣回报：$U_t=R_t+\gamma R_{t+1}+{\gamma }^{2}Rt+2+{\gamma }^{3}Rt+3....$
动作价值函数：$Q_{\pi }(s_t,a_t)=E[U_t|S_t=s_t,A_t=a_t]$
最优动作价值函数：$Q^{\ast }(s_t,a_t)=ma{x}_{\pi }{Q}_{\pi }(s_t,a_t)$

核心公式：时间差分算法

$Q(s_t,a_t;w)=r_t+\gamma {\max }_{a\in A}Q(s_{t+1},a;w)$
证明：略

公式解读及注意事项：
输入：（$s_t,a_t,r_t,s_{t+1}$）
左边项$Q(s_t,a_t;w)$ ： 是神经网络在t时刻的预测
右边 $r_t$是当前奖励值，${\max }_{a\in A}Q(s_{t+1},a;w)$
目标：使左右两边误差最小。

DQN 是对最优动作价值函数 Q⋆ 的近似。DQN 的输入是当前状态 st，输出是每个动作的 Q 值。DQN 要求动作空间 A 是离散集合

DQN高估问题：

1 最大化导致高估, 上式中总是取最大值，会导致高估
2 自举导致高估 上式中目标函数也用自己，使用自己估计自己，会导致高估
因此可以对目标函数进行以下改进。

目标函数分析：

$Q(s_t,a_t;w)=r_t+\gamma {\max }_{a\in A}Q(s_{t+1},a;w)$

• a .左右两边可以使用统一个Q函数
  b. 左右两边使用不同Q函数
  

c. 左右两边使用不同Q函数，且target 的$Q_{target}(s_{t+1},a;w)$ 的a 来自第一个函数${\max }_{a\in A}{Q}_1(s_{t+1},a;w)$

• 高估解决办法：
  b 策略可以减少自举带来的高估
  c 策略一定程度上能减少最大化带来的高估，因为用第一个Q函数中的a，在$Q_{target}$中总是小于等于最大值的${\max }_{a\in A}{Q}_{target}(s_{t+1},a;w)$ (DDQN方法)

3 核心代码实现DQN，DDQN

DQN 如下代码，

self.model为Q函数
self.model_target为目标Q函数，
s_batch :当前状态
a_batch：当前执行动作
r_batch: 奖励
d_batch ； 是否游戏结束
next_s_batch; 执行动作a_batch后，到下一个状态

self.model在当前状态s_batch下得到每个状态的Q值，选择a_batch对应的Q值，即为当前Q值
self.target_model 在下一步状态next_s_batch下，取self.target_model 最大值对应到a的值（DDQN，是在self.target_model中取self.model最大值对应a的值）。

    def compute_loss(self, s_batch, a_batch, r_batch, d_batch, next_s_batch):
        # Compute current Q value based on current states and actions.
        qvals = self.model(s_batch).gather(1, a_batch.unsqueeze(1)).squeeze()
        # next state的value不参与导数计算，避免不收敛。
        next_qvals, _ = self.target_model(next_s_batch).detach().max(dim=1)
        loss = F.mse_loss(r_batch + self.discount * next_qvals * (1 - d_batch), qvals)
        return loss

DDQN

与上面唯一区别是：使用Q1函数中的a

    def compute_loss(self, s_batch, a_batch, r_batch, d_batch, next_s_batch):
        # Compute current Q value based on current states and actions.
       Q1=self.model(s_batch)
       qvals =Q1 .gather(1, a_batch.unsqueeze(1)).squeeze()
       a_target =Q1argmax()
        # next state的value不参与导数计算，避免不收敛。
        next_qvals = self.target_model(next_s_batch).detach().gather(1, a_target).squeeze()
        loss = F.mse_loss(r_batch + self.discount * next_qvals * (1 - d_batch), qvals)
        return loss

   def get_action(self, obs):
        qvals = self.model(obs)
        return