强化学习多臂老虎机介绍【Multi-armed Bandits】

强化学习笔记

主要基于b站西湖大学赵世钰老师的【强化学习的数学原理】课程，个人觉得赵老师的课件深入浅出，很适合入门.

第一章 强化学习基本概念
第二章 贝尔曼方程
第三章 贝尔曼最优方程
第四章 值迭代和策略迭代
第五章 强化学习实践—GridWorld
第六章 蒙特卡洛方法
第七章 Robbins-Monro算法
第八章 多臂老虎机

---

---

Bandit（老虎机、赌博机）问题是强化学习领域中的一个经典问题，老虎机是一种用于赌博的机器，下拉老虎机的机械手臂，我们可以随机获得一个奖励。在赌场中，我们常常能看见很多老虎机被摆在一排，我们可以选择去下拉其中任何一只手臂，获得一个随机奖励，显然我们的目标是最大化奖励。在强化学习中我们将这种背景的问题称为多臂老虎机（Multi-armed Bandits)问题，后面缩写为abd。

一、问题描述

在abd问题中，每个老虎机的奖励值 r 的分布 $P(r|a)$​，它对于不同的老虎机来说是不同的，但是对某一台老虎机来说是固定的。比如是10-armed bandits，那么这个问题可以建模成如下的强化学习问题：

• 动作空间$\mathcal{A}$：$0,1,2,\cdots ,9.$
• 奖励：通常设置为正太分布$r_i\sim \mathcal{N}(q_i,1)，i=0,1,2,\cdots ,9.$
• 状态空间：显然这个问题是一个简化的MDP，可以视为没有状态空间.

如下图所示，10个老虎机的奖励分布都是方差为1的正太分布，但是均值不同。

我们在一开始是不知道每台老虎机的奖励分布$P(r|a)$（模型未知），而只能通过不断的实验和尝试来增进对分布的了解。假设我们实验n次，在每一次选择一个动作$A_t\in \mathcal{A}$，然后得到一个奖励$R_t\sim r_i$，得到如下的序列：
$$A_1,R_1,A_2,\cdots ,A_n,R_n.$$我们的目标是最大化累积回报:
$$G_n=\sum _{t=1}^n{R}_t.$$所以关键的问题是如何学习一个策略，使得尽量多的选择回报值更高的bandit,而这里就又涉及到Exploration和Exploitation的问题了。因为当n给定时，想要获得最大累积回报，是尽可能多的利用当前信息选择最优动作，还是多探索了解更多的信息呢，这也是不同算法所关心的问题。

二、动作值函数的估计

显然在abd问题中，我们需要估计$q(s,a)$，但这个问题没有$s$，所以可以简记为$q(a)$。通过前面介绍的Monte-calro方法(蒙特卡洛方法)，我们自然地可以想到用均值$Q_n(a)$来近似期望$q(a)$：
$$Q_n(a)\doteq \frac{\text{在时间 n 前选择动作 a 的奖励值的总和}}{\text{在时间 n 前动作 a 被选择的次数}}=\frac{{\sum }_{i=1}^{n-1}{R}_i\cdot 1_{A_i=a}}{{\sum }_{i=1}^{n-1}{1}_{A_i=a}},$$其中$1_x$ 的值在 $x$ 为真时为 1, 否则为 0。我们来看单个老虎机的$Q_n(a)$怎么计算：
$$Q_{n+1}(a)\doteq \frac{R_1+R_2+\cdots +R_n}{n}.$$
由前面介绍的Robbins-Monro算法，我们知道上式可以写成迭代的格式：
$$Q_{n+1}(a)=Q_n(a)-\frac{1}{n}(Q_n(a)-R_n)(1)$$其中$Q_1$是初始给定的，迭代的形式可以减少内存和计算的消耗。由RM算法我们知道，如果我们有无限的时间步长，那么就可以保证 $Q_n(a)$ 收敛为$q(a)$。我们知道(1)式更一般的形式如下：
$$Q_{n+1}=Q_n-{\alpha }_n(Q_n-R_n),(2)$$其中$a_n$为步长参数，由RM算法我们知道，要使算法收敛$a_n$需要满足：
$$\sum _1^{\infty }{\alpha }_n=\infty ,\sum _1^{\infty }{\alpha }_n^2<\infty .(3)$$${\alpha }_n=\frac{1}{n}$是满足上述条件的，但是这种取法是比较适合平稳的abd问题，也就是说每个老虎机的奖励分布不随时间改变。但是我们经常会遇到非平稳的强化学习问题，在这种情况下，给予近期奖励比过往奖励更大的权重是更合适的，最流行的方法之一是使用恒定的步长参数，即：
$$Q_{n+1}=Q_n-\alpha (Q_n-R_n),(4)$$通过递推，可以得到：
$$\begin{array}{rl}{Q}_{n+1}& =Q_n+\alpha (R_n-Q_n)\\ & =\alpha R_n+(1-\alpha )Q_n\\ & =\alpha R_n+(1-\alpha )\left[\alpha R_{n-1}+(1-\alpha )Q_{n-1}\right]\\ & =\alpha R_n+(1-\alpha )\alpha R_{n-1}+(1-\alpha {)}^2{Q}_{n-1}\\ & =\alpha R_n+(1-\alpha )\alpha R_{n-1}+(1-\alpha {)}^2\alpha R_{n-2}+\\ & \cdots +(1-\alpha {)}^{n-1}\alpha R_1+(1-\alpha {)}^n{Q}_1\\ & =(1-\alpha {)}^n{Q}_1+\sum _{i=1}^n\alpha (1-\alpha {)}^{n-i}{R}_i.\end{array}$$注意到$(1-\alpha {)}^n+{\sum }_{i=1}^n\alpha (1-\alpha {)}^{n-i}=1$，所以$Q_{n+1}$可以看作$Q_1,R_1,\cdots ,R_n$的加权和，距离最近的$R_n$有更大的权值，时间过去较久的$Q_1,R_1$等权值越来越小。（4）式不满足（3）的条件，所以$Q_n$不会严格收敛到$q(a)$，但是我们可以证明$\mathbb{E}[Q_n]=q(a)$，对（4）两边取期望，可得：
$$\mathbb{E}[Q_{n+1}]=(1-\alpha )\mathbb{E}[Q_n]+\alpha \mathbb{E}[R_n].$$$R_1,\cdots ,R_n$是关于同一个老虎机采样得到的独立同分布样本，不妨设$\mathbb{E}[R_n]=r$,并记$q_n=\mathbb{E}[Q_{n+1}]$，那么我们有:
$$\begin{array}{rl}|q_{n+1}-r|& =|\alpha r+(1-\alpha )q_n-r|\\ & =|(1-\alpha )(q_n-r)|\\ & ⋮\\ & =|(1-\alpha {)}^n(q_1-r)|\\ & \le |1-\alpha {|}^n|q_1-r|\end{array}$$显然如果当$|1-\alpha |<1$时，上式右端会趋于0，也就是说当$0<\alpha <2$时，我们有：
$$\mathbb{E}[Q_n]=r.$$所以我们用迭代法进行估计仍然是可行的。当然上面这个推导是针对Stationary的情况，Nonstationary的情况更复杂，这里就不展开了。第五节我们通过实验可以发现在非平稳情况下，$\alpha$取固定值的效果确实更好！

三、$ϵ$-greedy策略

通过前面几章的学习我们知道，贪心策略可以写成：
$$A_t=\arg \underset{a}{\max }{Q}_t(a)$$然而，我们也可以把这个贪心策略转化成有一定探索性的策略，即让它以 $ϵ$ 的概率去探索其他动作，也就是$ϵ$-greedy策略：
$$A_t=\{\begin{array}{ll}\text{a random action}& \text{with probability ϵ},\\ \arg {\max }_a{Q}_t(a)& \text{with probability 1−ϵ}.\end{array}$$

下面我们实现$ϵ$-greedy策略，并看看不同的$ϵ$值有什么影响.

import numpy as np
import matplotlib.pyplot as plt

# create k-armed bandit
def k_abd(k):
    q_mean = np.random.normal(0, 1, k)
    return q_mean

def play(epsilon,q_mean):

    k = len(q_mean) # number of bandits
    
    reward = []
    total_reward = 0
    optimal_action_percentage = []
    N = np.zeros(k) # number of times each bandit was chosen
    Q = np.zeros(k) # estimated value
    optimal_action = 0
    optimal_index = np.argmax(q_mean)  # calculate optimal index once
    for i in range(2000):
        
        # epsilon greedy
        if np.random.rand() < epsilon:
            A = np.random.randint(k)
        else:
            A = np.argmax(Q)
        if A == optimal_index:
            optimal_action += 1
        R = np.random.normal(q_mean[A], 1)
        N[A] += 1
        Q[A] += (R - Q[A]) / N[A]
        total_reward += R
        reward.append(total_reward/(i+1))
        optimal_action_percentage.append(optimal_action/(i+1))
    return reward, optimal_action_percentage

k = 10
armed_bandit_10 = k_abd(k)
r1,qap1 = play(0,armed_bandit_10)
r2,qap2 = play(0.01,armed_bandit_10)
r3,qap3 = play(0.1,armed_bandit_10)

# plot
plt.figure(figsize=(10,5),dpi = 150)
plt.plot(r1,label='ε=0')
plt.plot(r2,label='ε=0.01')
plt.plot(r3,label='ε=0.1')
plt.legend()
plt.xlabel('Steps')
plt.ylabel('Average Reward')
plt.title('10-armed bandit problem')
plt.show()

plt.figure(figsize=(10,5),dpi = 150)
plt.plot(qap1,label='ε=0')
plt.plot(qap2,label='ε=0.01')
plt.plot(qap3,label='ε=0.1')
plt.legend()
plt.xlabel('Steps')
plt.ylabel('% Optimal Action')
plt.title('10-armed bandit problem')
plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(1)) 
plt.show()

下图显示了$ϵ$分别等于0,0.01,0.1时探索2000次的平均reward，我们可以看到贪心策略$(ϵ=0)$的平均奖励最低，$ϵ=0.01$时的平均奖励比$ϵ=0.1$时高。因为$ϵ$-greedy策略理论上最后都能找到最优动作，当找到最优动作后，$ϵ=0.01$时，选择最优动作的概率为$p=1-ϵ\approx 0.99$，而$ϵ=0.1$时，选择最优动作的概率为$p\approx 0.9$,所以$ϵ=0.01$时的平均奖励更高。

下图则是在实验中每种情况下选择最优动作的概率，我们可以看到$ϵ=0.01$时，$p\to 0.99$，而$ϵ=0.1$时，$p\to 0.9$.

四、UCB算法

由于动作价值估计的准确性总是存在不确定性，因此需要进行Exploration。贪心算法总是利用当前信息选择最优动作的算法，但实际上其他动作可能更好。$ϵ$-greedy策略有一定概率尝试其他动作，但不加区分，对那些接近贪婪或特别不确定的行动没有偏好。最好根据它们实际成为最优动作的潜力在非贪婪行动中进行选择，同时考虑它们的估计与最大值的接近程度以及这些估计中的不确定性。一个有效的方法是UCB算法，这里我们直接给出其策略更新公式（推导可以参考文献2）：
$$A_t\doteq \arg \underset{a}{\max }\left[Q_t(a)+c\sqrt{\frac{\ln t}{N_t(a)}}\right],$$
Python实现如下：

def play_ucb(c, q_mean):
    k = len(q_mean)  # number of bandits
    reward = []
    total_reward = 0
    N = np.zeros(k)  # number of times each bandit was chosen
    Q = np.zeros(k)  # estimated value

    for i in range(1, 2001):  # start from 1 to avoid division by zero in UCB calculation
        if np.min(N) == 0:
            # If any action has not been taken yet, take it to initialize all actions
            A = np.argmin(N)
        else:
            ucb_values = Q + c * np.sqrt(np.log(i) / N)
            A = np.argmax(ucb_values)
        
        R = np.random.normal(q_mean[A], 1)
        N[A] += 1
        Q[A] += (R - Q[A]) / N[A]
        total_reward += R
        reward.append(total_reward / i)

    return reward
rewards = play_ucb(2, armed_bandit_10)  # Example usage with c = 2
# plot reward
plt.figure(figsize=(10,5),dpi = 200)
plt.plot(rewards,label='UCB c=2')
plt.plot(r3,label='ε=0.1')
plt.xlabel('Steps')
plt.ylabel('Average Reward')
plt.title('10-armed bandit problem')
plt.legend()
plt.show()

下图展示了采用UCB算法和采用$ϵ=0.1$的$ϵ$-greedy算法的对比，可以看到UCB算的表现更好。

五、 非平稳老虎机

在上面我们提到对$Q_n$迭代更新时，${\alpha }_n=\frac{1}{n}$是比较适合平稳的abd问题，也就是说每个老虎机的奖励分布不随时间改变。但是我们经常会遇到非平稳的强化学习问题，在这种情况下，给予近期奖励比过往奖励更大的权重是更合适的，最流行的方法之一是使用恒定的步长参数。下面我们来验证一下是否是这样，我们考虑每个老虎机的$q$每一步会有一个$\mathcal{N}(0,0.01)$的噪声，代码如下：

import numpy as np
import matplotlib.pyplot as plt

# all bandits have the same initial q value
def initialize_q_means(k):
    return np.zeros(k)

# update q values with random noise
def update_q_means(q_means):
    return q_means + np.random.normal(0, 0.01, size=q_means.shape)

def simulate_bandit(k, steps, epsilon, alpha=None):
    q_means = initialize_q_means(k)
    rewards = {'sample_average': [], 'constant_step': []}
    optimal_action_counts = {'sample_average': [], 'constant_step': []}
    Q_sa = np.zeros(k)  # Q values for sample average
    Q_cs = np.zeros(k)  # Q values for constant step
    N = np.zeros(k)  
    
    total_rewards = {'sample_average': 0, 'constant_step': 0}
    optimal_actions = {'sample_average': 0, 'constant_step': 0}

    for step in range(steps):
        q_means = update_q_means(q_means)
        optimal_action = np.argmax(q_means)
        
        for strategy in ['sample_average', 'constant_step']:
            if np.random.rand() < epsilon:
                action = np.random.randint(k)
            else:
                if strategy == 'sample_average':
                    action = np.argmax(Q_sa)
                else:
                    action = np.argmax(Q_cs)
            
            reward = np.random.normal(q_means[action], 1)
            total_rewards[strategy] += reward
            if action == optimal_action:
                optimal_actions[strategy] += 1
            
            if strategy == 'sample_average':
                N[action] += 1
                Q_sa[action] += (reward - Q_sa[action]) / N[action]
            else:
                # constant step size, alpha = 0.1
                Q_cs[action] += alpha * (reward - Q_cs[action])

            rewards[strategy].append(total_rewards[strategy] / (step + 1))
            optimal_action_counts[strategy].append(optimal_actions[strategy] / (step + 1))
    
    return rewards, optimal_action_counts

# parameters
k = 10  
steps = 10000
epsilon = 0.1
alpha = 0.1

# simulate
rewards, optimal_action_counts = simulate_bandit(k, steps, epsilon, alpha)

# plot
plt.figure(figsize=(10, 8), dpi=150)
plt.subplot(2, 1, 1)
plt.plot(rewards['sample_average'], label='Sample Average')
plt.plot(rewards['constant_step'], label='Constant Step (alpha=0.1)')
plt.title('Average Rewards')
plt.xlabel('Steps')
plt.ylabel('Average Reward')
plt.legend()

plt.subplot(2, 1, 2)
plt.plot(optimal_action_counts['sample_average'], label='Sample Average')
plt.plot(optimal_action_counts['constant_step'], label='Constant Step (alpha=0.1)')
plt.title('Optimal Action Percentage')
plt.xlabel('Steps')
plt.ylabel('Optimal Action %')
plt.legend()

plt.tight_layout()
plt.show()

我们可以得到如下的结果，我们发现确实$\alpha$取固定步长，比取${\alpha }_n=\frac{1}{n}$效果要好。

以下是固定步长参数 $\alpha$ 效果更好的原因：

1. 非静态问题的特点是环境的行为（或潜在的奖励分布）随时间改变。当使用固定的 $\alpha$ 时，每次估计给予最新的奖励更大的权重，并逐渐忘记旧的奖励信息。这意味着估计的值能够快速适应环境的变化。而取平均值，则会随着时间逐渐给予历史奖励更多的权重，导致对环境变化的反应迟缓。
2. 数学上的偏差-方差权衡
   固定的 $\alpha$为估计带来了更高的偏差，但在变化的环境中减少了方差，使得估计更稳定。采样平均方法虽然理论上在静态问题中可以收敛到真实值，但在非静态问题中可能会由于累积了太多过时的信息而导致高方差，使得算法性能下降。

总之，固定的步长$\alpha$在处理需要快速反应的非静态环境中通常更为适合，因为它允许模型更快地适应最新的环境变化，而不是在老旧数据上花费太多计算资源。这在设计强化学习算法时是一个重要的考量，特别是在那些环境状态快速变化的应用场景中。

六、总结

本节我们介绍了强化学习中的老虎机问题，并介绍了解决老虎机问题的两种经典算法：$ϵ$-greedy算法和UCB算法，前者是我们在Monte-Carlo方法中介绍过的。同时通过Python实现了这两种算法，实现这两个算法可以加深我们对蒙特卡洛思想以及RM算法在强化学习中的应用的理解，在这个问题中，我们用蒙特卡洛的思想以及RM算法来估计$q(a)$，进而进行策略优化。

同时我们还探讨了RM算法中步长$\alpha$取值对与平稳问题和平稳问题的影响，验证了对与非平稳问题$\alpha$取固定值更好的结论。

当然关于老虎机问题研究和具体应用还有非常多，具体可以参考文献2.

七、参考文献

1. Sutton, Richard S., and Andrew G. Barto. Reinforcement learning: An introduction. MIT press, 2018.
2. Lattimore, Tor, and Csaba Szepesvári. Bandit algorithms. Cambridge University Press, 2020.