Q-learning原理及其实现方法_qlearning算法

声明

学习博客快乐的强化学习1——Q_Learning及其实现方法，加之自己的理解写成，同时欢迎大家访问原博客

前期回顾

python单独运行查看py文件中类里面的函数功能

简介

Q-Learning是一种 value-based 算法，即通过判断每一步 action 的 value来进行下一步的动作，以人物的左右移动为例，Q-Learning的核心Q-Table可以按照如下表示：

其中，在环境1下，向左得分为0，向右得分为0.1

在进行初始化时，给予一个概率值 e_greedy， 当处于环境1时，按照算法中的策略进行动作选择的概率为 e_greedy，而为了避免局部最优以及进行更多的探索，仍按照 1- e_greedy 的概率进行随机选择。

Q_learning算法

Q_learning算法流程

Q_learning算法理解

1. 建立Q表，行是每种状态，列是每种状态的行为，值是某状态下某行为估计获得的奖励
2. 每次进行状态转移时有e_greedy概率选当前状态最优方法，有 1- e_greedy选随机方法
3. 选完之后就更新当前状态下对应所选行为的Q值（估计值）
4. 更新方法：其自身= 其自身+学习率*（估计-现实） —> (实际更新 = 实际未更新+学习率*（预测-实际发生）)
   
   现实值也是其自身， 估计值是选择当前行为后的奖励及下一状态中选择与当前状态具有相同行为的Q值

PS：建议结合以下的例子理解。

Q_learning算法实现

以小男孩取得玩具为例子，讲述Q-Learning算法的执行过程。

在一开始的时候假设小男孩不知道玩具在哪里，他的Q_Table一片空白，此时他开始观测自己所处的环境，这个环境是环境1，并将这个环境加入到Q_Table中。此时，他不知道左右两个环境的情况，所以向左走向右走的得分都是0， 这两个得分都是小男孩心中预测出来的，并不是真实的左右两个环境的得分，我们给这个得分一个名字叫做q_predict。

往左走往右走都是有可能的，如果他往左走，他会到达环境0，环境0是一个深渊，然后小男孩就挂了。此时环境会给他一个反馈得分，由于他掉入了深渊，所以他的得分是-1， 这个得分是环境0的实际得分，与上面小男孩处于环境1对环境0的预测得分不同，我们给这个得分一个名字叫做q_target， 由于这个得分与上一步预测的环境0的得分不同，所以我们需要对上一个表格进行更新，此时他的Q_Table表为：

此时小男孩重生了，在这一轮假设他会选择往右走，此时他到达了环境2，并将这个环境加入到Q_Table中。此时，他不知道这个新环境的情况，向左走和向右走对他来说是一样的，所以这个新环境的左右两个Actions得分都是0。

此时他会随机选择一个方向走，之后不断重复探测新环境和走回旧环境的过程，如果他在不断测试中找到了最后的toys，他会得到正数得分，这个得分会一步一步驱使他走向toys。在经过许多次的尝试之后，小男孩会找到一条最快通向玩具的道路。假设环境4就是玩具，小男孩在经过多次尝试后，最后的Q_Table可能是这样。

对于Q-Learning算法的主体而言，Q-Learning算法主要由两个对象组成，分别是Q-Learning的大脑和大环境。
Q-Learning的大脑包括以下部分，其对应的功能为

大环境包括以下部分，其对应的功能为

在完成两个对象的构建后，需要有一个主函数将两个对象联系起来使用，主函数需要完成以下功能，以伪代码的形式呈现：

初始化测试环境对象
初始化Q-Learning的大脑对象
for episode in range(TIMES):
	环境观察
	图画更新
	while(1):
		终点观察
		if(到达终点):
			打印当前进行世代数，共使用多少步数
			参数归零
			break;
		动作选择
		获取下一步的环境的实际情况
		学习
		更新坐标
		图画更新
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在观察完Q_Learning算法的伪代码后我们可以发现， 大脑在获取下一步环境的实际情况之后再进行学习，学习函数对Q-Table表更新的重要参数之一就是获取下一步的环境的实际情况。 具体来说，在进行学习过程时，Q-Learning的大脑对象会根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况（最大得分）对当前环境的Q-Table表进行更新，具体的代码如下所示

---

1.QL.py

import numpy as np
import pandas as pd

class QL:
    def __init__(self, actions, learning_rate=0.05, reward_decay=0.9, e_greedy=0.9):
        self.actions = actions      #初始化可以进行的各种行为，传入为列表
        self.lr = learning_rate     #学习率，用于更新Q_table的值
        self.gamma = reward_decay   #当没有到达终点时，下一环境对当前环境的影响
        self.epsilon = e_greedy     #随机选择几率为1-e_greedy，当处于e_greedy内时，不随机选择。
        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)     #生成q_table，列向量为columns

    def choose_action(self,observation):
        self.check_observation(observation)        #检测是否到达过这个点，如果没到达过，在Q表中增加这个节点
        action_list = self.q_table.loc[observation,:]           #取出当前observation所在的不同方向
        
        if(np.random.uniform() < self.epsilon):    #如果在epsilon几率内
            action = np.random.choice(action_list[action_list == np.max(action_list)].index)    #选出当前observation中Q值最大的方向
        else:
            action = np.random.choice(self.actions)      #如果不在epsilon内，则随机选择一个动作
        return action                                    #返回应当做的action

    def learn(self,observation_now,action,score,observation_after,done):
        self.check_observation(observation_after)        #检查是否存在下一环境对应的方向状态
        q_predict = self.q_table.loc[observation_now,action]        #获得当前状态下，当前所作动作所对应的预测得分
        if done:
            q_target = score     #如果完成了则q_target为下一个环境的实际情况得分，本例子中此时score为1
        else:
            q_target = score + self.gamma * self.q_table.loc[observation_after, :].max()  #如果未完成则取下一个环境若干个动作中的最大得分作为这个环境的价值传递给当前环境
        #根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
        self.q_table.loc[observation_now, action] += self.lr * (q_target - q_predict)  

    def check_observation(self,observation):
        if observation not in self.q_table.index:               #如果不存在 
            self.q_table = self.q_table.append(                 #则通过series函数生成新的一列
                pd.Series(
                    [0]*len(self.actions),
                    index=self.actions,
                    name=observation,)
            )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2. Env.py

import numpy as np
import pandas as pd
import time 

class Env:
    def __init__(self,column,maze_column):
        self.column = column                        #表示地图的长度
        self.maze_column = maze_column - 1          #宝藏所在的位置
        self.x = 0                                  #初始化x
        self.map = np.arange(column)                #给予每个地点一个标号
        self.count = 0                              #用于技术一共走了多少步
        

    def draw(self):
        a = []
        for j in range(self.column) :               #更新图画
            if j == self.x:
                a.append('o')
            elif j == self.maze_column:
                a.append('m')
            else:
                a.append('_')
        interaction = ''.join(a)
        print('\r{}'.format(interaction),end = '')
        

    def get_observation(self):
        return self.map[self.x]                     #返回现在在所


    def get_terminal(self):
        if self.x == self.maze_column:              #如果得到了宝藏，则返回已经完成
            done = True
        else:
            done = False
        return done


    def update_place(self,action):
        self.count += 1                              #更新的时候表示已经走了一步
        if action == 'right':                                  
            if self.x < self.column - 1:
                self.x += 1
        elif action == 'left':   #left
            if self.x > 0:
                self.x -= 1

    def get_target(self,action):
        if action == 'right':                        #获得下一步的环境的实际情况
            if self.x + 1 == self.maze_column:
                score = 1
                pre_done = True
            else:
                score = 0
                pre_done = False
            return self.map[self.x + 1],score,pre_done
        elif action == 'left':   #left
            if self.x - 1 == self.maze_column:
                score = 1
                pre_done = Ture
            else:
                score = 0
                pre_done = False
            return self.map[self.x - 1],score,pre_done
        
    def retry(self):            #初始化
        self.x = 0
        self.count = 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

3. run_this.py

from Env import Env
from QL import QL
import time

LONG = 6                    #总长度为6
MAZE_PLACE = 6              #宝藏在第六位
TIMES = 15                  #进行15次迭代

people = QL(['left','right'])       #生成QLearn主体的对象，包含left和right
site = Env(LONG,MAZE_PLACE)         #生成测试环境
for episode in range(TIMES):
    state = site.get_observation()  #观察初始环境
    site.draw()                     #生成图像
    time.sleep(0.3)                 #暂停
    while(1):
        done = site.get_terminal()  #判断当前环境是否到达最后
        if done:                    #如果到达，则初始化
            interaction = '\n第%s次世代，共使用步数：%s。'%(episode+1 ,site.count)
            print(interaction)
            site.retry()
            time.sleep(2)
            break
        action = people.choose_action(state)                        #获得下一步方向
        state_after,score,pre_done = site.get_target(action)        #获得下一步的环境的实际情况
        people.learn(state,action,score,state_after,pre_done)       #根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
        site.update_place(action)                                   #更新位置
        state = state_after                                         #状态更新
        site.draw()                                                 #更新画布
        time.sleep(0.3)
    

print(people.q_table)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

结果为：

_____o
第1次迭代，共使用步数：44
_____o
第2次迭代，共使用步数：11
_____o
第3次迭代，共使用步数：6
_____o
第4次迭代，共使用步数：6
_____o
第5次迭代，共使用步数：5
_____o
第6次迭代，共使用步数：7
_____o
第7次迭代，共使用步数：5
_____o
第8次迭代，共使用步数：5
_____o
第9次迭代，共使用步数：5
_____o
第10次迭代，共使用步数：5
_____o
第11次迭代，共使用步数：5
_____o
第12次迭代，共使用步数：5
_____o
第13次迭代，共使用步数：5
_____o
第14次迭代，共使用步数：5
_____o
第15次迭代，共使用步数：5
       left     right
0  0.000000  0.000452
5  0.000000  0.000000
1  0.000000  0.004429
2  0.000000  0.031661
3  0.000000  0.159344
4  0.001327  0.536709
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

知识拓展

快捷键批量注释/取消注释、缩进/取消缩进
python中join函数
Python中format函数用法说明
python中format函数