【强化学习笔记】基于蒙特卡洛的强化学习算法

[code]import numpy as np
import pandas as pd
import random

class MC_RL(object):

def __init__(self, states_list, action_lists, gamma):
self.states = states_list
self.actions = action_lists
self.gamma = gamma

# 返回按照随机规则生成的 num 组实验的state_sample,action_sample,reward_sample(起始点随机+中间过程中选择动作也完全随机)
def gen_randompi_sample(self, num):  # 采集num次的实验
state_sample = []
action_sample = []
reward_sample = []
for i in range(num):
s_tmp = []
a_tmp = []
r_tmp = []
# 随机选择“初始状态”
s = self.states[int(random.random() * len(self.states))]
t = False  # 标记是否到达终点
while t == False:
a = self.actions[int(random.random() * len(self.actions))]  # 过程中随机选择“动作”
t, state_next, r = self.transform(s, a)
# t:这次行动是否到达终点
# state_next:这次行动后到达了哪一个状态
# r:这次行动获得的奖励
s = state_next
# 接下来更新实验的轨迹
s_tmp.append(s)
a_tmp.append(a)
r_tmp.appned(r)
# 当跳出循环时，s_tmp a_tmp r_tmp  已经是完整过程（起点——>终点）的序列了
state_sample.append(s_tmp)
reward_sample.append(r_tmp)
action_sample.append(a_tmp)
return state_sample, action_sample, reward_sample

# 输入：采样的state_sample,action_sample,reward_sample
# 返回： 更新后的vfunc，里面是每一个状态对应的值函数
def mc_evaluate(self, state_sample, action_sample, reward_sample):
vfunc = dict()
nfunc = dict()
for s in self.states:
vfunc[s] = 0.0
nfunc[s] = 0.0
for iter1 in range(len(state_sample)):  # 遍历num组实验
G = 0.0  # 要针对每组实验，计算每一组实验的初始状态 的 累计回报
for step in range(len(state_sample[iter1]) - 1, -1, -1):
G = G * self.gamma
G = G + reward_sample[iter1][step]
# 对于此条实验的初始状态的累计回报 G ,计算完毕。

# 接下来 正向计算 每条状态的 累计回报G
for step in range(len(state_sample[iter1])):
s = state_sample[iter1][step]
vfunc[s] = vfunc[s] + G
nfunc[s] = nfunc[s] + 1
G = (G - reward_sample[iter1][step]) / self.gamma
#  至此，所有状态处 的 累计回报值 更新完毕
for s in self.states:
if nfunc[s] >= 1:
vfunc[s] = vfunc[s] / nfunc[s]
print("MC_SAMPLE完毕")
return vfunc

# ****************************** 以上两个方法实现了蒙特卡洛评估*********************************************

# ****************************** 接下来用蒙特卡洛实现 策略改进 即 对q（s,a）进行更新**************************

# 输入： 策略改进时候的采样轮数 and epsilon   （策略改进的时候，对动作的选取，采用的策略是epsilon-greedy策略）
# 输出： 蒙特卡洛改进后的 状态-动作 函数
def mc(self, num_iter, epsilon):
qfunc = dict()  # 根据greedy策略生成 策略改进 的采样样本时，需要使用到qfunc，我们在这里提前定义好
nqfunc = dict()
for s in self.states:
for a in self.actions:
qfunc["%s_%d" % (s, a)] = 0.0  # 动作 用字符串表示 ， 状态 用整数表示
nqfunc["%s_%d" % (s, a)] = 0.0
# 策略改进过程中，生成采样的策略是epsilon-greedy策略,下面就是epsilon-greedy采样部分
for iter in range(num_iter):
s_sample = []
a_sample = []
r_sample = []
# epsilon-greedy的策略要求：先随机选一个初始点，在接下来过程中的动作选择中，遵循epsilon-greedy策略
s = self.states[int(random.random() * len(self.states))]
t = False  # 标记是否到达终点
while t == False:
a = epsilon_greedy(qfunc, s, epsilon)  # epsilon_greedy()未定义 按需求自己给出
r, s_next, t = env_grid.transform(s, a)  # env_grid 是环境
s_sample.append(s)
a_sample.append(a)
r_sample.append(r)
s = s_next
# 针对刚才生成的一幕完整的实验episode，进行 策略改进（计算出现在episode中的每一个 状态-动作对，若出现多次）
g = 0.0
# 计算采样序列的 起始状态的 回报值 g
for i in range(len(s_sample) - 1, -1, -1):  # 反向遍历采样到的序列
g = g * self.gamma
g = g + r_sample[i]
# 正向遍历采样到的序列 当中的 每一个 状态-动作对
for i in range(len(s_sample)):
key = "%d_%s" % (s_sample[i], a_sample[i])
nqfunc[key] = nqfunc[key] + 1
# 把新的s-a的回报g 和 旧的 qfunc[s,a]的回报 ，一起重新计算，求得  更新后的 qfunc[s,a]
qfunc[key] = (qfunc[key] * (nqfunc[key] - 1) + g) / nqfunc[key]
# 现在的g对应的是i，针对下一个状态i+1，更新下一个状态的回报g
g = (g - r_sample[i]) / self.gamma
# 总体思路是： 进行 num_iter 轮采样，每一轮采样后对策略q(s,a)进行一次更新
# 更新的具体做法是： 遍历采样序列的每一个s-a对，根据本轮新求得的每一个sa的回报，综合以前求得sa的回报，根据经历sa的次数，做平均
return qfunc

直接上代码 注释很清楚了 初学 有误麻烦帮忙指正