• Q-Learning

    一、什么是Q-learning

            Q-Learning是强化学习中，一种基于值(values-based)的算法，最终的return是一个表格，即Q-Table。这个表格的每一行都代表着一个状态（state），每一行的每一列都代表着一个动作（action），而每个值就代表着如果在该state下，采取该action所能获取的最大的未来期望奖励。通过Q-Table就可以找到每个状态下的最优行为，进而通过找到所有的最优action来最终得到最大的期望奖励。

    二、马尔科夫奖励模型（Markov Reward Process，MRP）

            马尔科夫奖励模型是带回报值的马尔可夫模型

    马尔科夫奖励模型的定义：

    1、S 是有限个状态的集合s∈S；

    2、P 是一个动态转移模型；

    3、R 是一个奖励函数；

    4、γ 衰减因子。

     回报 & 值函数

    马尔可夫决策过程（马尔可夫过程 + 奖励 + 动作）

     马尔可夫决策过程的策略：

    1、对于MDP，希望得到一个策略 \pi，对于每一个状态，都能给予一个动作；

    2、策略可以是固定的，也可是随机的；

    3、更一般地说，我们会将其视为一个条件概率分布；

    4、最优策略\pi*：一个执行之后能得到最大回报的策略

    马尔可夫决策过程的搜索树：

     三、贝尔曼方程

     收敛性：

     四、Q-Learning算法流程

    在这里插入图片描述

    1、建立Q表；

    2、选择当前状态的最优action（或设置一定概率随机选择action）

    3、执行选择的action，更新当前状态下所选行为的Q值（估计值）

    4、更新方法：

    在这里插入图片描述

     五、算法实例1

    实例情况：

            环境为一个直长廊，直长廊正前方，有一个钻石，直长廊后面，是一个深渊。此处一个Agent，可选择的action有两个，分别是left和right。设定：掉进深渊，score为-1，得到钻石，score为+1 ，其余score均为0 。

            可以根据下方图画理解：

            如图，这个长得像小人的，就是Agent，它左侧阴影部分，就是深渊，掉进去就-1；离它较远的右侧，有一个粉红的球，就是钻石，得到就是+1.

            我们可以画一个表格，来抽象化一下环境和奖励：

    深渊-1Agent起始位置0000钻石+1
    0123456

    这个表格第一行就是地图，第二行是地图下标。

    我们规定，Agent有只有两种动作，Left和Right，也就是左和右。

    代码大致流程可以写出：

    1、初始化，初始化环境参数、Agent参数；

    2、图画更新，为便于用户观察，动态展示Agent位置；

    3、Agent观察环境，看是否经历过这个state，如果经历过就选最优action，如果没有就随机action；

    4、执行3所选的action；

    5、观察终点，看是否到终点或是否掉入深渊；

    6、更新坐标；

    7、获取下一环境；

    8、学习；

    9、参数归零；

    10、2-9迭代，直到5成立。

    伪代码形式：

    1. 初始化测试环境对象
    2. 初始化Agent
    3. 循环：
    4. 	环境观察
    5. 	图画更新
    6. 	while(1):
    7. 		终点观察
    8. 		if(到达终点):
    9. 			参数归零
    10. 			break;
    11. 		动作选择
    12. 		获取下一步的环境的实际情况
    13. 		学习
    14. 		更新坐标
    15. 		图画更新

    下面展示一下实际代码：

    首先是环境代码：

    Env.py

            这是环境代码，主要功能包括：生成图像、获取所在位置、检测是否到终点、更新当前位置、获取下一步的实际情况和初始化地图

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn
    4. @File ：Env.py
    5. @Author ：Hao
    6. @Date ：2022-09-10 010 8:38
    7. """
    8. import numpy as np
    9.  
    10.  
    11. class Env:
    12.     def __init__(self, column, start_colum, maze_column):
    13.         self.column = column  # 表示地图的长度
    14.         self.maze_column = maze_column - 1  # 宝藏所在的位置
    15.         self.x = start_colum  # 初始化x
    16.         self.map = np.arange(column)  # 给予每个地点一个标号
    17.         self.count = 0  # 用于记录一共走了多少步
    18.  
    19.     # 生成图像
    20.     def draw(self):
    21.         a = []
    22.         for j in range(self.column):  # 更新图画
    23.             if j == 0:
    24.                 a.append('x')
    25.             elif j == self.x:
    26.                 a.append('o')
    27.             elif j == self.maze_column:
    28.                 a.append('m')
    29.             else:
    30.                 a.append('_')
    31.         interaction = ''.join(a)
    32.         print('\r{}'.format(interaction), end='')
    33.  
    34.     # 获取所在位置
    35.     def get_observation(self):
    36.         return self.map[self.x]  # 返回现在所在位置
    37.  
    38.     # 是否已到达终点
    39.     def get_terminal(self):
    40.         if self.x == self.maze_column:  # 如果得到了宝藏，则返回已经完成
    41.             done = True
    42.         elif self.x == 0:  # 如果掉入左边边缘，失败，-1
    43.             done = True
    44.         else:
    45.             done = False
    46.         return done
    47.  
    48.     # 更新当前位置
    49.     def update_place(self, action):
    50.         self.count += 1  # 更新的时候表示已经走了一步
    51.         if action == 'right':
    52.             if self.x < self.column - 1:
    53.                 self.x += 1
    54.         elif action == 'left':  # left
    55.             if self.x > 0:
    56.                 self.x -= 1
    57.  
    58.     # 获得下一步的环境的实际情况
    59.     def get_target(self, action):
    60.         if action == 'right':  # 获得下一步的环境的实际情况
    61.             if self.x + 1 == self.maze_column:
    62.                 score = 1
    63.                 pre_done = True
    64.             else:
    65.                 score = 0
    66.                 pre_done = False
    67.             return self.map[self.x + 1], score, pre_done
    68.         elif action == 'left':  # left
    69.             if self.x - 1 == self.maze_column:
    70.                 score = 1
    71.                 pre_done = True
    72.             elif self.x - 1 == 0:
    73.                 score = -1
    74.                 pre_done = True
    75.             else:
    76.                 score = 0
    77.                 pre_done = False
    78.             return self.map[self.x - 1], score, pre_done
    79.  
    80.     # 初始化，位置0，计数器归零
    81.     def retry(self, start_colum):  # 初始化
    82.         self.x = start_colum
    83.         self.count = 0

    Agent.py

            这是智能体的初始化、选择行动和学习的代码。

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn
    4. @File ：Env.py
    5. @Author ：Hao
    6. @Date ：2022-09-10 010 8:38
    7. @Describe ：Agent
    8. """
    9. import numpy as np
    10. import pandas as pd
    11.  
    12.  
    13. class Agent:
    14.     def __init__(self, actions, long, learning_rate=0.05, reward_decay=0.9, e_greedy=0.9):
    15.         self.actions = actions  # 初始化可以进行的各种行为，传入为列表
    16.         self.lr = learning_rate  # 学习率，用于更新Q_table的值
    17.         self.gamma = reward_decay  # 当没有到达终点时，下一环境对当前环境的影响
    18.         # self.epsilon = e_greedy  # 随机选择几率为1-e_greedy，当处于e_greedy内时，不随机选择。
    19.         self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)  # 生成q_table，列向量为columns
    20.         for i in range(long):
    21.             line_table = pd.Series(
    22.                 [0.0, 0.0],
    23.                 name=i,
    24.                 index=actions
    25.             )
    26.             line_table_2_frame = line_table.to_frame()
    27.             self.q_table = pd.concat([self.q_table, line_table_2_frame.T])
    28.  
    29.     # 选择行动
    30.     def choose_action(self, observation):
    31.         action_list = self.q_table.loc[observation, :]  # 取出当前observation所在的不同方向
    32.  
    33.         # if np.random.uniform() < self.epsilon:  # 如果在epsilon几率内
    34.         #     # 选出当前observation中Q值最大的方向，这里再加一个random.choice是为了防止出现两个概率相同
    35.         #     action = np.random.choice(action_list[action_list == np.max(action_list)].index)
    36.         # else:
    37.         #     action = np.random.choice(self.actions)  # 如果不在epsilon内，则随机选择一个动作
    38.  
    39.         action = np.random.choice(action_list[action_list == np.max(action_list)].index)  # action总选择最优解
    40.         return action  # 返回应当做的action
    41.  
    42.     # 学习
    43.     def learn(self, observation_now, action, score, observation_after, done):
    44.         q_predict = self.q_table.loc[observation_now, action]  # 获得当前状态下，当前所作动作所对应的预测得分
    45.         if done:
    46.             q_target = score  # 如果完成了则q_target为下一个环境的实际情况得分，本例子中此时score为1
    47.         else:
    48.             # 如果未完成则取下一个环境若干个动作中的最大得分作为这个环境的价值传递给当前环境
    49.             q_target = score + self.gamma * self.q_table.loc[observation_after, :].max()
    50.  
    51.         # 根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
    52.         self.q_table.loc[observation_now, action] += self.lr * (q_target - q_predict)

            此处的选择行动，可以设置一定的随机率，比如说设置为0.9的几率为选择Q-table中最优的action，剩下0.1的概率让agent随机选择。或者是不设置随机率，每一步都贪心。

    接下来是main

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn 
    4. @File ：run_this.py
    5. @Author ：Hao
    6. @Date ：2022-09-10 010 8:40 
    7. """
    8. from Env import Env
    9. from Agent import Agent
    10. import time
    11. import pandas
    12.  
    13. LONG = 7  # 总长度为6
    14. START_PLACE = 1  # 游戏开始的位置
    15. MAZE_PLACE = 7  # 宝藏在第六位
    16. TIMES = 1000  # 限制最大1000次循环，防止死循环
    17. STOP_FLAG = False
    18. e = 1e-2
    19.  
    20. people = Agent(['left', 'right'], LONG)  # 生成QLearn主体的对象，包含left和right，传入两个action
    21. site = Env(LONG, START_PLACE, MAZE_PLACE)  # 生成测试环境
    22. for episode in range(TIMES):
    23.     state = site.get_observation()  # 观察初始环境
    24.     site.draw()  # 生成图像
    25.     time.sleep(0.2)  # 暂停
    26.     while True:
    27.         done = site.get_terminal()  # 判断当前环境是否到达最后
    28.         if done:  # 如果到达，则初始化
    29.             interaction = '\n第%s次episode，共使用步数：%s。' % (episode + 1, site.count)
    30.             print(interaction)
    31.             # 存储本次记录，计算与上次最大差值
    32.             fileName = "data/episode" + str(episode) + ".csv"
    33.             people.q_table.to_csv(fileName)  # 将本次的q_table存储到本地文件中
    34.             # print(f"\n第{episode}轮数据：\n{people.q_table}\n")
    35.             if episode != 0:  # 第一轮不进行判断
    36.                 old_file_name = "data/episode" + str(episode - 1) + ".csv"  # 读取上一次的q_table
    37.                 old_q_table = pandas.read_csv(old_file_name, index_col=0)
    38.                 # print(f"\n第{episode - 1}轮数据：\n{old_q_table}\n")
    39.                 difference = (people.q_table - old_q_table).abs()
    40.                 # print(f"两次差值：\n{difference}\n")
    41.                 max_difference = difference.max()[0] \
    42.                     if difference.max()[0] >= difference.max()[1] else difference.max()[1]
    43.                 # print(f"与上一次最大差值：\n{difference.max()}\n{difference.max()[0]},{difference.max()[1]}\n")
    44.                 print(f"最大差值：{max_difference}"
    45.                       f"\n------{episode + 1}------")
    46.                 if max_difference <= e:  # 达到收敛条件
    47.                     STOP_FLAG = True
    48.                     break
    49.             site.retry(START_PLACE)  # 初始化
    50.             time.sleep(0.5)
    51.             break
    52.         action = people.choose_action(state)  # 获得下一步方向
    53.         state_after, score, pre_done = site.get_target(action)  # 获得下一步的环境的实际情况
    54.         people.learn(state, action, score, state_after, pre_done)  # 根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
    55.         site.update_place(action)  # 更新位置
    56.         state = state_after  # 状态更新
    57.         site.draw()  # 更新画布
    58.         time.sleep(0.2)
    59.     if STOP_FLAG:
    60.         break
    61.  
    62. print(people.q_table)

            这里可以设置两种结束条件，一种是比较简单的设置循环次数，比如说循环20次、50次就强制结束，此种方法的缺点是，不能保证此结果已经收敛；还有一种方法是，加上收敛的判定条件，比如以上代码设置了判断收敛的方法，即判断本次Q-table的和上一次Q-table最大的差值，是否小于设定的一个阙值，若小于此阙值，则已经收敛，若不小于，则继续迭代。

    六、算法实例2

             这次实例是上一次的升级版本，这次是二维环境，action也变成了四个，分别是up、down、left和right，同样是一个Agent要获取钻石，即SUCCESS，到达之后会score+1，如果到FAIL，就是score-1，图中阴影部分，是一堵墙，无法穿过，图中的边缘部分，无法穿过，例如在起始位置，往上或者往左，都是无法移动（但是计步器会+1）。而且为了让Agent最快的找到SUCESS，这里设定Agent每走一步，都会获得一个-0.02的score。

    此次的Environment.py

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn 
    4. @File ：environment.py
    5. @Author ：Hao
    6. @Date ：2022-09-15 015 15:51 
    7. @Describe ：
    8. """
    9. import numpy as np
    10.  
    11.  
    12. class Environment:
    13.     def __init__(self, map_high, map_width, wall_place, success_place, fail_place):
    14.         self.map_high = map_high  # 初始化地图
    15.         self.map_width = map_width
    16.         self.x = 0  # 初始化Agent所在坐标
    17.         self.y = 0
    18.         self.wall_place = wall_place  # 初始化墙的位置
    19.         self.success_place = success_place  # 初始化成功坐标
    20.         self.fail_place = fail_place  # 初始化失败坐标
    21.         self.map = np.arange(map_width * map_high)  # 给予每个地点一个标号(width * y + x)
    22.         self.count = 0  # 用于记录一共走了多少步
    23.         print(f"Environment初始化成功！\n"
    24.               f"map_high:{self.map_high}, map_width:{self.map_width}\n"
    25.               f"wall:{self.wall_place},success:{self.success_place},fail:{self.fail_place}")
    26.  
    27.     # 打印地图
    28.     def print_map(self):
    29.         print(f"\n------MAP------")
    30.         for x in range(self.map_high):
    31.             for y in range(self.map_width):
    32.                 if x == self.wall_place[0] and y == self.wall_place[1]:
    33.                     print(f"#", end=' ')
    34.                 elif x == self.success_place[0] and y == self.success_place[1]:
    35.                     print(f"√", end=' ')
    36.                 elif x == self.fail_place[0] and y == self.fail_place[1]:
    37.                     print(f"X", end=' ')
    38.                 else:
    39.                     print(f"{x * self.map_width + y}", end=' ')
    40.             print()
    41.         print(f'------MAP------\n')
    42.  
    43.     # 获取所在位置
    44.     def get_observation(self):
    45.         return self.map[self.x * self.map_width + self.y]  # 返回现在所在位置
    46.  
    47.     # 更新当前位置
    48.     def update_place(self, action):
    49.         self.count += 1
    50.         if action == 'down':  # down
    51.             if self.x < self.map_high - 1:
    52.                 if self.y == self.wall_place[1] and self.x + 1 == self.wall_place[0]:
    53.                     pass
    54.                 else:
    55.                     # print(f"{self.x, self.y}--> down --> ", end='')
    56.                     self.x += 1
    57.                     # print(f"{self.x, self.y}")
    58.  
    59.         elif action == 'up':  # up
    60.             if self.x > 0:
    61.                 if self.y == self.wall_place[1] and self.x - 1 == self.wall_place[0]:
    62.                     pass
    63.                 else:
    64.                     # print(f"{self.x, self.y}--> up--> ", end='')
    65.                     self.x -= 1
    66.                     # print(f"{self.x, self.y}")
    67.  
    68.         elif action == 'left':  # left
    69.             if self.y > 0:
    70.                 if self.x == self.wall_place[0] and self.y - 1 == self.wall_place[1]:
    71.                     pass
    72.                 else:
    73.                     # print(f"{self.x, self.y}--> left -->", end='')
    74.                     self.y -= 1
    75.                     # print(f"{self.x, self.y}")
    76.  
    77.         elif action == 'right':  # right
    78.             if self.y < self.map_width - 1:
    79.                 if self.x == self.wall_place[0] and self.y + 1 == self.wall_place[1]:
    80.                     pass
    81.                 else:
    82.                     # print(f"{self.x, self.y}--> right --> ", end='')
    83.                     self.y += 1
    84.                     # print(f"{self.x, self.y}")
    85.  
    86.     # 是否已到达终点
    87.     def get_terminal(self):
    88.         if self.x == self.success_place[0] and self.y == self.success_place[1]:
    89.             done = True
    90.         elif self.x == self.fail_place[0] and self.y == self.fail_place[1]:
    91.             done = True
    92.         else:
    93.             done = False
    94.         return done
    95.  
    96.     # 获得下一步的环境的实际情况
    97.     def get_target(self, action):
    98.         if action == 'down':
    99.             if self.x + 1 == self.success_place[0] and self.y == self.success_place[1]:
    100.                 score = 1
    101.                 pre_done = True
    102.             elif self.x + 1 == self.fail_place[0] and self.y == self.fail_place[1]:
    103.                 score = -1
    104.                 pre_done = True
    105.             else:
    106.                 score = -0.02
    107.                 pre_done = False
    108.             if self.x == self.map_high - 1:
    109.                 return self.map[self.x * self.map_width + self.y], score, pre_done
    110.             else:
    111.                 if self.x + 1 == self.wall_place[0] and self.y == self.wall_place[1]:
    112.                     return self.map[self.x * self.map_width + self.y], score, pre_done
    113.                 return self.map[(self.x + 1) * self.map_width + self.y], score, pre_done
    114.         elif action == 'up':
    115.             if self.x - 1 == self.success_place[0] and self.y == self.success_place[1]:
    116.                 score = 1
    117.                 pre_done = True
    118.             elif self.x - 1 == self.fail_place[0] and self.y == self.fail_place[1]:
    119.                 score = -1
    120.                 pre_done = True
    121.             else:
    122.                 score = -0.02
    123.                 pre_done = False
    124.             if self.x == 0:
    125.                 return self.map[self.x * self.map_width + self.y], score, pre_done
    126.             else:
    127.                 if self.x - 1 == self.wall_place[0] and self.y == self.wall_place[1]:
    128.                     return self.map[self.x * self.map_width + self.y], score, pre_done
    129.                 return self.map[(self.x - 1) * self.map_width + self.y], score, pre_done
    130.         elif action == 'left':
    131.             if self.y - 1 == self.success_place[1] and self.x == self.success_place[0]:
    132.                 score = 1
    133.                 pre_done = True
    134.             elif self.y - 1 == self.fail_place[1] and self.x == self.fail_place[0]:
    135.                 score = -1
    136.                 pre_done = True
    137.             else:
    138.                 score = -0.02
    139.                 pre_done = False
    140.             if self.y == 0:
    141.                 return self.map[self.x * self.map_width + self.y], score, pre_done
    142.             else:
    143.                 if self.y - 1 == self.wall_place[0] and self.x == self.wall_place[1]:
    144.                     return self.map[self.x * self.map_width + self.y], score, pre_done
    145.                 return self.map[self.x * self.map_width + self.y - 1], score, pre_done
    146.         elif action == 'right':
    147.             if self.y + 1 == self.success_place[1] and self.x == self.success_place[0]:
    148.                 score = 1
    149.                 pre_done = True
    150.             elif self.y + 1 == self.fail_place[1] and self.x == self.fail_place[0]:
    151.                 score = -1
    152.                 pre_done = True
    153.             else:
    154.                 score = -0.02
    155.                 pre_done = False
    156.             if self.y == self.map_width - 1:
    157.                 return self.map[self.x * self.map_width + self.y], score, pre_done
    158.             else:
    159.                 if self.y + 1 == self.wall_place[0] and self.x == self.wall_place[1]:
    160.                     return self.map[self.x * self.map_width + self.y], score, pre_done
    161.                 return self.map[self.x * self.map_width + self.y + 1], score, pre_done
    162.  
    163.     # 初始化，位置0，计数器归零
    164.     def retry(self, start_colum):  # 初始化
    165.         self.x = start_colum
    166.         self.y = start_colum
    167.         self.count = 0

    此案例的Agent.py

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn
    4. @File ：agent.py
    5. @Author ：Hao
    6. @Date ：2022-09-15 015 15:51
    7. @Describe ：
    8. """
    9. import numpy as np
    10. import pandas as pd
    11.  
    12.  
    13. class Agent:
    14.     def __init__(self, actions, long, learning_rate=0.05, reward_decay=0.9, e_greedy=1):
    15.         self.actions = actions  # 初始化可以进行的各种行为，传入为列表
    16.         self.lr = learning_rate  # 学习率，用于更新Q_table的值
    17.         self.gamma = reward_decay  # 衰减因子
    18.         self.epsilon = e_greedy  # 随机选择几率为1-e_greedy，当处于e_greedy内时，不随机选择。
    19.         self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64)  # 生成q_table，列向量为columns
    20.         for i in range(long):  # 向新建的q_table插入与二维格子相同数量的行向量
    21.             line_table = pd.Series(
    22.                 [0.0, 0.0, 0.0, 0.0],
    23.                 name=i,
    24.                 index=actions
    25.             )
    26.             line_table_2_frame = line_table.to_frame()
    27.             self.q_table = pd.concat([self.q_table, line_table_2_frame.T])
    28.         print(f"Agent初始化成功！\n"
    29.               f"{self.q_table}")
    30.  
    31.     # 贪心选择行动
    32.     def choose_action_greed(self, observation):
    33.         action_list = self.q_table.loc[observation, :]  # 取出当前observation所在的不同方向
    34.         action = np.random.choice(action_list[action_list == np.max(action_list)].index)  # action总选择最优解
    35.  
    36.         return action  # 返回应当做的action
    37.  
    38.     # 伴有部分随机选择
    39.     def choose_action(self, observation):
    40.         action_list = self.q_table.loc[observation, :]  # 取出当前observation所在的不同方向
    41.  
    42.         if np.random.uniform() < self.epsilon:  # 如果在epsilon几率内
    43.             # 选出当前observation中Q值最大的方向，这里再加一个random.choice是为了防止出现两个概率相同
    44.             action = np.random.choice(action_list[action_list == np.max(action_list)].index)
    45.         else:
    46.             action = np.random.choice(self.actions)  # 如果不在epsilon内，则随机选择一个动作
    47.  
    48.         return action  # 返回应当做的action
    49.  
    50.     # 学习
    51.     def learn(self, observation_now, action, score, observation_after, done):
    52.         q_predict = self.q_table.loc[observation_now, action]  # 获得当前状态下，当前所作动作所对应的预测得分
    53.         if done:
    54.             # 如果完成了则q_target为下一个环境的实际情况得分，本例子中此时score为1
    55.             q_target = score
    56.         else:
    57.             # 如果未完成则取下一个环境若干个动作中的最大得分作为这个环境的价值传递给当前环境
    58.             q_target = score + self.gamma * self.q_table.loc[observation_after, :].max()
    59.  
    60.         # 根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
    61.         self.q_table.loc[observation_now, action] += self.lr * (q_target - q_predict)
    62.

    这里给了两种行为选择方式，一种是全部贪心，一种是伴有10%的随机选择。

    main.py

    1. # -*- coding: utf-8 -*-
    2. """
    3. @Project ：Q_learn 
    4. @File ：main.py
    5. @Author ：Hao
    6. @Date ：2022-09-15 015 15:50 
    7. @Describe ：
    8. """
    9. import time
    10.  
    11. from environment import Environment
    12. from agent import Agent
    13. from find_max import find_max
    14. import pandas
    15. import matplotlib.pyplot as plt
    16.  
    17. MAP_HIGH = 3
    18. MAP_WIDTH = 4
    19. WALL_PLACE = [1, 1]
    20. SUCCESS_PLACE = [2, 3]
    21. FAIL_PLACE = [1, 3]
    22. TIMES = 200
    23. e = 1e-4
    24.  
    25. # site.print_map()
    26. E_LIST = []
    27.  
    28.  
    29. def train(learn_function):
    30.     robot = Agent(['left', 'right', 'up', 'down'], MAP_HIGH * MAP_WIDTH)  # 生成Agent
    31.     site = Environment(MAP_HIGH, MAP_WIDTH, WALL_PLACE, SUCCESS_PLACE, FAIL_PLACE)  # 生成环境
    32.     STOP_FLAG = False
    33.     for episode in range(TIMES):
    34.         state = site.get_observation()
    35.         while True:
    36.             done = site.get_terminal()  # 判断当前环境是否到达最后
    37.             if done:
    38.                 interaction = '\n%s--第%s次episode，共使用步数：%s。' % (learn_function, episode + 1, site.count)
    39.                 print(interaction)
    40.                 # 存储本次记录，方便后续计算与上次最大差值
    41.                 fileName = "data/" + str(learn_function) + "_episode" + str(episode) + ".csv"
    42.                 robot.q_table.to_csv(fileName)  # 将本次的q_table存储到本地文件中
    43.                 if episode != 0:
    44.                     old_file_name = "data/" + str(learn_function) + "_episode" + str(
    45.                         episode - 1) + ".csv"  # 读取上一次的q_table
    46.                     old_q_table = pandas.read_csv(old_file_name, index_col=0)
    47.                     difference = (robot.q_table - old_q_table).abs()
    48.                     max_difference = find_max(difference.max())
    49.                     print(max_difference)
    50.                     print(f"最大差值：{max_difference}"
    51.                           f"\n------{episode + 2}------")
    52.                     E_LIST.append(max_difference)
    53.                     if max_difference <= e:
    54.                         STOP_FLAG = True
    55.                         break
    56.                 site.retry(0)
    57.                 break
    58.             if learn_function == 'greed':  # 贪心
    59.                 action = robot.choose_action_greed(state)  # 获得下一步方向
    60.             else:
    61.                 action = robot.choose_action(state)  # 获得下一步方向
    62.             state_after, score, pre_done = site.get_target(action)  # 获得下一步的环境的实际情况
    63.             robot.learn(state, action, score, state_after, pre_done)  # 根据所处的当前环境对各个动作的预测得分和下一步的环境的实际情况更新当前环境的q表
    64.             site.update_place(action)  # 更新位置
    65.             # print(f"state_now: {state}, action: {action}, state_after: {state_after}")
    66.             state = state_after
    67.         if STOP_FLAG:
    68.             site.retry(0)
    69.             break
    70.  
    71.  
    72. train('greed')
    73. random_e_list = E_LIST.copy()
    74. E_LIST.clear()
    75. train('random')
    76. greed_e_list = E_LIST.copy()
    77.  
    78. plt.title('greed and random')
    79. plt.plot(greed_e_list, 'b--', random_e_list, 'g')
    80. plt.xlabel('Iterations')
    81. plt.ylabel('Adjacent difference')
    82. plt.legend(['choose_action_greed', 'choose_action_random1'], loc=1)
    83. plt.savefig('./photo/greed_random1.svg', dpi=300)  # svg文件，可伸缩矢量图形
    84. plt.show()
    85. # print(f"greed_e_list:\n{greed_e_list}")
    86. # print(f"random_e_list:\n{random_e_list}")

    还有一个小工具类，find_max.py

    1. def find_max(different_max):
    2.     max = -9999
    3.     for i in range(4):
    4.         if different_max[i] >= max:
    5.             max = different_max[i]
    6.     return max

    代码的最后，最生成图像，可以看到收敛曲线

  • 相关阅读:
    高效使用python之xlwt库编辑写入excel表内容
    数字孪生论文阅读笔记【3】
    Ansible自动化部署安装openGauss3.1企业版单机
    计算机、通信方向学习考证经验分享
    [k8s] kubectl port-forward 和kubectl expose的区别
    【算法】Inclusion of a Shuffled String Into another String
    鸿蒙Harmony应用开发—ArkTS声明式开发（触摸交互控制：触摸测试控制）
    2024Node.js零基础教程(小白友好型)，nodejs新手到高手，（九）NodeJS入门——http模块
    RUST运算符重载
    我来谈谈“人工智能”这个词给我带来了哪些想法
  • 原文地址：https://blog.csdn.net/Hao_ge_666/article/details/126894658