强化学习编程实战-1-一个及其简单的强化学习实例（多臂赌博机）

1.1 多臂赌博机

一台拥有K个臂的机器，玩家每次可以摇动K个臂中的一个，摇动后，会吐出数量不等的金币，吐出金币的数量服从一定的概率分布，而且不同臂的概率分布不同。

多臂赌博机的问题是：假设玩家共有N次摇地摇臂的机会，每次如何选择摇动才能使N轮之后得到的金币最多？

对于这个问题，如果提前知道哪个臂吐的金币最多，那么可以每次都摇动那个臂。但是，问题使并不知道那个臂能获得最多金币？该采取什么策略？

1.1.1 $eq?%5Cvarepsilon$ -greedy策略

一个很直观的想法：既然不知道哪个臂吐的金币最多，那么可以先对每个臂都尝试几次（如都10次），找出那个臂吐出的金币最多，然后一直摇动它。

其实这个最简单、最朴素的想法已经蕴含了算法学习最基本的两个过程：采集数据和学习。首先，对每个臂进行尝试就是采集数据，其次，学习就是利用这些数据知道哪个臂回吐出最多的金币。一个最简单的方法就是计算每个臂的平均吐钱数量，然后，一直摇那个臂。

我们可以将这个算法用形式化的代数来表示。用s表示当前赌博机，用A表示可以选择的动作，即A={1，2，3}。其中a=1表示摇动第一个臂，依次类推。用回报 $eq?%5Cgamma$ 表示摇动赌博机的摇臂后获得的金币的数目。用Q（a）表示摇动动作a获得的金币的平均回报，则 $eq?Q%28a%29%3D%5Cfrac%7B1%7D%7Bn%7D%5Csum_%7Bi%3D1%7D%5E%7Bn%7D%5Cgamma%20_%7Bi%7D$ ,其中n为摇动动作的总次数。R（a）为摇动动作a的总回报。

算法的伪代码

1-3行：初始化每个动作的总回报R（a），以及摇动该动作的次数N（a）。

4-6行：每个臂都尝试 $eq?n_%7Ba%7D$ 次，计算每个摇臂总的金币数。

7-9行：算出使得总回报最大的那个臂，然后一直摇动它。

这是一个简单、朴素的想法，但并不是一个好的算法。原因如下：缺点
（1）不应该以总回报最大为目的来选择当前哪个臂，而是应该选择当前平均回报最大的臂。

（2）不应该只摇动当前平均回报最大的臂，因为它不一定使最好的那个臂。所以，我们除了关注当前平均回报最大的臂，还要保留一定的概率去摇动其他的臂，以便发现更好的臂。

以上两点对应着强化学习算法中最重要的概念：利用策略和探索策略平衡。

利用：exploitation,是利用当前的数据总结得到的最好的策略，采用该策略，我们可以得到较高的回报。

探索：exploration，该策略可以帮我们找到更好的臂，甚至找到最优的臂。

强化学习算法在训练的过程中所用到的策略是平衡了利用和探索的策略，最常见的是 $eq?%5Cvarepsilon$ -greedy策略，公式表示：

该策略，在每次选择摇动哪个臂时，应该以1- $eq?%5Cvarepsilon$ 的概率去摇动当前平均值最大的臂，以 $eq?%5Cvarepsilon$ 的概率在所有动作中均匀随机地选择动作。这样可以在有限的次数中得到尽可能多的回报，同时不失去找到最好的臂的机会。

第1-4行：初始化总回报R(a)，初始化每个动作的平均回报Q（a）,每个动作的次数N（a）.

第6行：在每次摇臂之前，采用 $eq?%5Cvarepsilon$ -greedy策略，选择要摇动的臂a。

第7行：动作a的次数N(a)+1.

第8行：根据动作a和环境返回的回报 $eq?%5Cgamma_%7B%7D$ (a),更新动作a的平均回报。

第9行：计算总的收益。

第10行：玩家尝试N次之后，返回总的收益。

在多臂赌博机中，平衡利用和探索的策略还有玻尔兹曼策略和UCB策略。

1.1.2 玻尔兹曼策略

e-greedy策略给对应值函数最大的那个动作一个比较大的概率，而其他动作，不管值函数的大小如何，被采样的概率都是相等。

但这中概率的分配策略不太合理。按理说，非贪婪的动作也有好坏之分，那些对应值函数大的动作应该比那些对应值函数小的动作采样的概率大。于是玻尔兹曼策略根据值函数对动作的采样的概率进行了软处理，表示下式1-2为

其中 $eq?%5Ctau$ 为温度调节参数，可以用来调节探索和利用和比例。 $eq?%5Ctau$ $eq?%5Ctau$ 越小，玻尔兹曼越接近贪婪策略，利用所占的比例越大，探索越少。反之，探索越多。伪代码只需替换图1-3中的e-greedy策略为公式1-2.

1.1.3 UCB策略

UCB（Upper Confidence Boundn）置信上限。在统计学中常常用置信区间来表示不确定性。在这里，我们用置信区间来表示探索。

UCB策略公式

其中t为当前摇臂动作的总次数，N（a）为动作a的总次数。

下图为3种策略，总回报和摇动次数之后的关系。e-greedy策略回报最低，但却是形式最简单、最通用，可广泛用于各种任务的学习和探索训练中。

1.2 多臂赌博机代码实现

基于上文提到的三种学习策略。

①首先，我们先创建一个KB_Game类，

②在类KB_Game中定义方法step（），用于模拟多臂赌博机如何给出回报。该方法的输入为动作，输出为回报。用正态分布来模拟玩家在每次摇动摇臂后得到的回报。step（）方法实际上提供了多臂赌博机的模拟器。

③接下来，实现3种选择动作的策略方法choose_action().该方法的输入参数为测量类别policy，有3种，对应上文的三种策略e_greedy,ucb和boltzmann.另外还有一个参数字典**kwargs,对应传递相应的策略的所对应超参数，如e-greedy策略中的epsilon，UCB策略中的超参数c_ratio,以及玻尔兹曼中的温度‘temperature'.UCB算法的每一步是依次摇动每个臂，因此在程序中对应的代码为判断每个动作的次数，如果有等于零的，那么选择该动作。

④有了模拟器和动作选择策略，下面就可以通过交互进行学习训练。定义方法train().该方法的输入参数有play_total（表示训练的总次数）,policy（训练的策略）,**kwargs（相应策略的超参数字典）.

⑤智能体通过学习的策略选择动作，然后将动作传给step()方法，相当于跟多臂赌博机进行了一次交互，从多臂赌博机中获得回报r,智能体根据立即回报更新每个动作的平均回报q,计算当前的累计回报并作相应的保存。

⑥在每次训练新的策略的时候，我们需要将类KB_Game中的成员变量进行重置，定义reset（）方法进行重置，重置的变量有平均回报q,各动作的次数action_counts,当前的累积回报current_cumulative_reward,玩家尝试的次数counts,玩家尝试的历史counts_history、玩家累积回报的历史cumulative_rewards_history、动作a、回报reward。

⑦为了更直观比较3种不同策略的学习性能，需要画图展示，我们用方法plot()来实现。得到如下的结果。显然ucb比其他两个策略要好。

代码如下

import numpy as np
import matplotlib.pyplot as plt
class KB_Game:
    def __init__(self,*args,**kwargs):
        self.q=np.array([0.0,0.0,0.0])          #每个臂的平均回报
        self.action_counts=np.array([0,0,0])    #摇动每个臂的次数
        self.current_cumulative_rewards=0.0     #当前累积回报总和
        self.actions=[1,2,3]                    #3个不同的摇臂
        self.counts=0                           #玩家玩游戏的次数
        self.counts_history=[]                  #玩家而玩游戏的次数记录
        self.cumulative_rewards_history=[] #累积回报的记录
        self.a=1                  #玩家当前动作，初始化为1，摇第一个摇臂
        self.reward=0             #当前回报，初始值为0

    def step(self,a):#模拟器
        r=0
        if a==1:
            r=np.random.normal(1,1)     #正态分布，均值为1，方差为1
        if a==2:
            r=np.random.normal(2,1)
        if a==3:
            r=np.random.normal(1.5,1)
        return r
    
    def choose_action(self,policy,**kwargs):  #动作策略
        action=0
        if policy=='e_greedy':
            if np.random.random()<kwargs['epsilon']:
                action=np.random.randint(1,4)
            else:
                action=np.argmax(self.q)+1
        if policy=='ucb':
            c_ratio=kwargs['c_ratio']
            if 0 in self.action_counts:
                action=np.where(self.action_counts==0)[0][0]+1
            else:
                value=self.q+c_ratio*np.sqrt(np.log(self.counts)/self.action_counts)
                action=np.argmax(value)+1
        if policy=='boltzmann':
            tau=kwargs['temperature']
            p=np.exp(self.q/tau)/(np.sum(np.exp(self.q/tau)))
            action=np.random.choice([1,2,3],p=p.ravel())
        return action
    
    def train(self,play_total,policy,**kwargs):
        reward_1=[]
        reward_2=[]
        reward_3=[]
        for i in range(play_total):
            action=0
            if policy=='e_greedy':
                action=self.choose_action(policy,epsilon=kwargs['epsilon'])
            if policy=='ucb':
                action=self.choose_action(policy,c_ratio=kwargs['c_ratio'])
            if policy=='boltzmann':
                action=self.choose_action(policy,temperature=kwargs['temperature'])
            self.a=action
            #print(self.a)
            #与环境交互一次
            self.r=self.step(self.a)
            self.counts+=1
            #更新值函数
            self.q[self.a-1]=(self.q[self.a-1]*self.action_counts[self.a-1]+self.r)/(self.action_counts[self.a-1]+1)
            self.action_counts[self.a-1]+=1
            reward_1.append([self.q[0]])
            reward_2.append([self.q[1]])
            reward_3.append([self.q[2]])
            self.current_cumulative_rewards+=self.r
            self.cumulative_rewards_history.append(self.current_cumulative_rewards)
            self.counts_history.append(i)
            
    def reset(self):
        self.q=np.array([0.0,0.0,0.0])          #每个臂的平均回报
        self.action_counts=np.array([0,0,0])    #摇动每个臂的次数
        self.current_cumulative_rewards=0.0     #当前累积回报总和
        self.counts=0                           #玩家玩游戏的次数
        self.counts_history=[]                  #玩家而玩游戏的次数记录
        self.cumulative_rewards_history=[] #累积回报的记录
        self.a=1                  #玩家当前动作，初始化为1，摇第一个摇臂
        self.reward=0             #当前回报，初始值为0
    
    def plot(self,colors,policy,style):
        plt.figure(1)       #创建画布
        plt.plot(self.counts_history,self.cumulative_rewards_history,colors,label=policy)
        plt.legend() #加上图列
        plt.xlabel('n',fontsize=18)
        plt.ylabel('total rewards',fontsize=18)
        

if __name__=='__main__':
    np.random.seed(0)
    k_gamble=KB_Game()
    total=2000
    k_gamble.train(play_total=total,policy='e_greedy',epsilon=0.05)
    k_gamble.plot(colors='r',policy='e_greedy',style='-.')
    k_gamble.reset()
    k_gamble.train(play_total=total,policy='boltzmann',temperature=1)
    k_gamble.plot(colors='b',policy='boltzmann',style='--')
    k_gamble.reset()
    k_gamble.train(play_total=total,policy='ucb',c_ratio=0.5)
    k_gamble.plot(colors='g',policy='ucb',style='-')
    plt.show()