从零实践强化学习之基于表格型方法求解RL(PARL)

小蒋的学习笔记

已于 2022-11-18 15:10:02 修改

阅读量435

点赞数 1

文章标签：学习

于 2022-11-17 22:12:12 首次发布

桂林电子科技大学计算机与信息安全学院蒋熹煜

本文链接：https://blog.csdn.net/qq_61735602/article/details/127905973

版权

Lesson2-1 MDP、Q表格

一、强化学习MDP四元组<S,A,P,R>

S:state 状态
A:action 动作
R:reward 奖励 r[s_t,a_t]
P:probability 状态转移概率 p[s_t+1,r_t|s_t,a_t]

强化学习是一系列决策的过程,通过当前的环境状态和收到的奖励来决定下一次执行的动作

Model-based: P函数和R函数已知
Model-free：P函数和R函数未知

二、Q表格：状态动作价值

Q(s_t,a_t)	装死	跑	action…
S_t	0	-90	…
S_t+1	0	10	…
state…	…	…	…

未来总收益引出：如果一辆车闯红灯，他扣一分。但是如果它运送病人，闯红灯扣一分，把病人送到病人加一百分，所以这时候就应该闯红灯。强化学习目光放长远一点决策。

但是目光也不能太过长远，如股票，考虑太长远的反而不合理，所以需要引入衰减因子。

Reward 折扣因子γ，未来总收益计算需要从终点开始往前计算
- G_t=R_t+1+γR_t+2+γ²R_t+2+γ³R_t+2+…
使用例子来说明强化学习更新Q表格

请添加图片描述

Q表格用来指导每一步动作。每走一步，会更新一次Q表格，用下一个状态的Q值去更新当前状态的Q值

大佬讲解

Lesson2-2-强化概念、TD更新、Sarsa引入

强化概念：巴普洛夫的条件反射实验

在这里插入图片描述

解释：食物对小狗有一种无条件的刺激,而铃声是中性的,一开始并不会对小狗有刺激;而如果在每次喂食前先响一下铃,重复多次后,响铃对小狗来说也会产生一种刺激,会开始流口水,也就是说,声音会代表着有食物,对小狗来说也就有了价值

巴普洛夫实验强调的是中性的条件刺激在跟无条件刺激紧紧挨着的时候,经过反复多次,这种中性的条件刺激也能引起和无条件刺激一样的条件反应。

中性刺激和无条件刺激紧紧挨着，中性刺激也能引起无条件反应。

解释：假设人走在树林里,先看到树上有熊爪后看到熊,接着就看到熊发怒了,经过很多次之后,原来要见到熊才瑟瑟发抖的,后来只要见到树上有熊爪就会有晕眩和害怕的感觉。也就是说,在不断地训练之后,下一个状态的价值可以不断地强化、影响上一个状态的价值

请添加图片描述

斯坦福大学的在线实验：状态价值迭代

原文链接：https://cs.stanford.edu/people/karpathy/reinforcejs/gridworld_td.html

Temporal Difference 时序查分（单步更新）

Q(S_t,A_t) ⭠ Q(S_t,A_t)+α[R_t+1+γQ(S_t+1,A_t+1)-Q(S_t,A_t)]

用下一个Q来更新当前Q
Target目标值 R_t+1+γQ(S_t+1,A_t+1)
当前值 Q(S_t,A_t)
软更新用 R_t+1+γQ(S_t+1,A_t+1)-Q(S_t,A_t) 软更新Q(S_t,A_t)
逼近 Q 理想中的值

请添加图片描述

Sarsa 算法

请添加图片描述

代码的实现思路
- 根据Q表格选动作
  - 带探索 sample()
  - 仅评估 predict()
- 更新Q表格
  - Learn()

请添加图片描述

智能体每次跟环境交互一次以后,就可以从环境当中拿到一个状态和收益(智能体主要依据Q表格选动作),然后拿到这些值以后,就用来更新Q表格

Lesson 2-3 Sarsa算法介绍

请添加图片描述

伪代码

obs = env.reset() # 重置环境, 重新开一局（即开始新的一个episode）
action = agent.sample(obs) # 根据 Q表格 选择一个动作

while True:
    next_obs, reward, done, _ = env.step(action) # 与环境进行一个交互
    next_action = agent.sample(next_obs) # 根据算法选择一个动作
    # 训练  Sarsa 算法
    agent.learn(obs, action, reward, next_obs, next_action, done) # 更新 Q表格 
    action = next_action
    obs = next_obs  # 存储上一个观察值

ε-greedy

请添加图片描述

有一定概率选择已有的最优动作也有一定的概率去将没有使用过的动作利用起来

伪代码

# 根据输入观察值，采样输出的动作值，带探索
def sample(self, obs):
    if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作
        action = self.predict(obs)
    else:
        action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作
    return action

# 根据输入观察值，预测输出的动作值
def predict(self, obs):
    Q_list = self.Q[obs, :]
    maxQ = np.max(Q_list)
    action_list = np.where(Q_list == maxQ)[0]  # maxQ可能对应多个action ,所以随机选择一个
    action = np.random.choice(action_list)
    return action

Sarsa与环境交互代码，每个Step都更新learn一下

请添加图片描述

def run_episode(env, agent, render=False):
	total_steps= 0#记最每个episode走了多少step
	total_reward = 0
	
  obs = env.reset() # 重置环境，重新开一局（即开始新的一个episode）
	action = agent.sample(obs）# 根据算法选择一个动作

	while True:
		next_obs, reward, done, _ = env.step(action) # 与环境进行一次交互
		next_action = agent.sampte(next_obs) # 根据算法选择一个动作
		# 训练 Sarsa 算法
		agent.learn(obs, action, reward, next_obs, next_action, done)
		action = next_action
		obs = next_obs # 存储上一个观察值
		total_reward += reward
		total_steps += 1 #计算step数
		if render:
			env.render() #渲染新的一帧图片
		if done:
			break
	return total_reward, total_steps

Sarsa Agent ①根据Q表格选动作

class SarsaAgent(object):
  def __init__(self,obs_n,act_n,learning_rate=0.01,gamma=0.9,e_greed=0.1):
    self.act_n=act_n	# 动作维度，有几个动作可选
    self.lr=learning_rate	# 学习率
    self.gamma=gamma	# reward的衰减率
    self.epsilon=e_greed	#按一定的概率随机选动作
    self.Q=np.zeros((obs_n,act_n)) #Q表格
    
  # 根据输入观察值，采样输出的动作值，带探索
	def sample(self, obs):
  	  if np.random.uniform(0, 1) < (1.0 - self.epsilon): #根据table的Q值选动作
    	    action = self.predict(obs)
  	  else:
  	      action = np.random.choice(self.act_n) #有一定概率随机探索选取一个动作
 	   return action

	# 根据输入观察值，预测输出的动作值
	def predict(self, obs):
 	   Q_list = self.Q[obs, :]
  	 maxQ = np.max(Q_list)
 	   action_list = np.where(Q_list == maxQ)[0]  # maxQ可能对应多个action ,所以随机选择一个
  	 action = np.random.choice(action_list)
   	 return action

Sarsa Agent ②更新Q表格

# 学习方法，也就是更新Q-table的方法
def learn(self, obs, action, reward, next_obs, next_action, done):
    """ on-policy
        obs: 交互前的obs, s_t
        action: 本次交互选择的action, a_t
        reward: 本次动作获得的奖励r
        next_obs: 本次交互后的obs, s_t+1
        next_action: 根据当前Q表格, 针对next_obs会选择的动作, a_t+1
        done: episode是否结束
    """
    predict_Q = self.Q[obs, action]
    if done:
        target_Q = reward # 没有下一个状态了
    else:
        target_Q = reward + self.gamma * self.Q[next_obs, next_action] # Sarsa
    self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q

请添加图片描述

公式里的α就是学习率learning_rate,代码也是完全按照公式写的,另外,如果一个回合结束了,就没有下一个状态了,这一步代码要记得加上,否则可能无法收敛

main函数写法

import gym
from gridworld import CliffwalkingWapper
from agent import SarsaAgent
def main():
	env = gym.make("CliffWalking-v0") # 0 up, 1 right, 2 down, 3 left
	env = CliffwalkingWapper(env)
	agent = SarsaAgent(
	obs_n=env.observation_space.n,
	act_n=env.action_space.n,
	learning_rate=0.1,
	gamma=0.9,
	e_greed=0.1)
  
	is render = False
	for episode in range(500):
		ep_reward, ep_steps = run_episode(env, agent, is_render)
		print('Episode %s: steps = %s , reward
	%.1f' %(episode, ep_steps, ep_reward))
	# 每隔 20个 episode 渲染一下看看效果
	if episode % 20 == 0:
		is_render = True
	else:
		is_render = False
	# 训练结束，查看算法效果
	test_episode (env, agent)

def test_episode(env, agent):
	total_reward = 0
	obs = env.reset()
	while True:
		action = agent.predict(obs) # greedy
		next_obs, reward, done,= env.step(action)
		total_ reward + reward
		obs = next_ obs
		time. sleep(0.5)
		env. render()
		if done:
			print ('test reward = %.1f' %(total reward))
			break

Sarsa 会远离悬崖走，比较小心

Off-Policy

实际上有两种不同的策略,期望得到最佳的目标策略和大胆探索的行为策略

请添加图片描述

On-Policy

on-policy优化的实际上是它实际执行的策略,用下一步一定会执行的动作action来优化Q表格,所以on-policy其实只存在一种策略 ,用同一种策略去选取和优化

Q-learning vs Sarsa

请添加图片描述

Q-learning解析

Q-learning也是采用Q表格的方式存储Q值（状态动作价值），决策部分与Sarsa是一样的，采用ε-greedy方式增加探索。

Q-learning跟Sarsa不一样的地方是更新Q表格的方式。

Sarsa是on-policy的更新方式，先做出动作再更新。

Q-learning是off-policy的更新方式，更新learn()时无需获取下一步实际做出的动作next_action，并假设下一步动作是取最大Q值的动作。

Q-learning 默认使用的是下一个状态的Q最大动作

Q-learning Agent①根据Q表格选懂动作

class QLearningAgent(object):
	def __init__(self, obs_n, act_n, learning_ rate=0.01, gamma=0.9, e_greed=0.1):
	self.act_n = act_n	# 动作维度，有几个动作可选
	self.lr = learning_rate # 学习率
	self.gamma = gamma # reward的衰减率
	self.epsilon = e_greed # 按一定的概率选动作
	self.Q = np.zeros((obs_n, act_n))
  
  # 根据输入的观察值，采样输出的动作值，带探索
	def sample(self, obs):
		if np. random. uniform(0, 1) < (1.0 - self.epsilon): # 根据table 的Q值选动作
			action = self.predict (obs)
		else:
			action = np.random.choice(self.act_n） # 有一定概率随机探索选取一个动作
		return action
	
  # 根据输入观察值，预测输出的动作值
	def predict(self,	obs):
		Q_list = self.Q[obs, :]
		maxQ=np.max(Q_list)
		action_list = np.where(Q_list - maxQ)[0] # maxQ可能对应多个action
		action = np.random.choice(action_list)
		return action

Q-learning Agent ②更新Q表格

 # 学习方法，也就是更新Q-table的方法
    def learn(self, obs, action, reward, next_obs, done):
        """ off-policy
            obs: 交互前的obs, s_t
            action: 本次交互选择的action, a_t
            reward: 本次动作获得的奖励r
            next_obs: 本次交互后的obs, s_t+1
            done: episode是否结束
        """
        predict_Q = self.Q[obs, action]
        if done:
            target_Q = reward # 没有下一个状态了
        else:
            target_Q = reward + self.gamma * np.max(self.Q[next_obs, :]) # Q-learning
        self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q

运行展示

import gym
from gridworld import CliffwalkingWapper
from agent import QLearningAgent
def main():
	env = gym.make("CliffWalking-v0") # 0 up, 1 right, 2 down, 3 left
	env = CliffwalkingWapper(env)
	agent = QLearningAgent(
	obs_n=env.observation_space.n,
	act_n=env.action_space.n,
	learning_rate=0.1,
	gamma=0.9,
	e_greed=0.1)
  
	is render = False
	for episode in range(500):
		ep_reward, ep_steps = run_episode(env, agent, is_render)
		print('Episode %s: steps = %s , reward
	%.1f' %(episode, ep_steps, ep_reward))
	# 每隔 20个 episode 渲染一下看看效果
	if episode % 20 == 0:
		is_render = True
	else:
		is_render = False
	# 训练结束，查看算法效果
	test_episode (env, agent)

def test_episode(env, agent):
	total_reward = 0
	obs = env.reset()
	while True:
		action = agent.predict(obs) # greedy
		next_obs, reward, done,= env.step(action)
		total_ reward + reward
		obs = next_ obs
		time. sleep(0.5)
		env. render()
		if done:
			print ('test reward = %.1f' %(total reward))
			break

代码lesson2/q_learning

请添加图片描述

总结

请添加图片描述

课后作业

使用Q-learning和Sarsa解决16宫格寻迹问题
- 可以使用FrozenLakeWapper美化render界面
- 注意is_slippery参数

[界面链接](#https://github.com/openai/gym/wiki/FrozenLake-v0
from gridworld import FrozenLake Wapper
env = gym.make(“FrozenLake-vO”, is_ slippery=False) # 0 left, 1 down, 2 right, 3 up
env = FrozenLake Wapper(env))

请添加图片描述

from gridworld import FrozenLakeWapper
env = gym.make("FrozenLake-v0",is_slippery=False)#0 left,1 down,2 right,3 up
env = FrozenLakeWapper(env)

gridworld.py 使用指南

# 环境1：FrozenLake,可以配置冰面是否是滑的
env = gym.make ("FrozenLake-v0", is_slippery=False) # 0 left, I down, 2 right, 3 up
env = FRozenLakeWapper(env)

# 环境2： CLiffWalking，悬崖环境
env = gym.make ("Cliffwalking-v0") # 0 up, 1 right, 2 down, 3 left
en = CliffwalkingWapper(env)

# 环境3：自定义格子世界，可以配置地固，S为出发点Start，F为平地Floor， H为洞Hole，G为出口目标Goal
gridmap = [
		'SFFF'
		'FHFF'
		'FFFF'
		'HFGF']
env = Gridworld(gridmap)