强化学习实战（一）：用值迭代和策略迭代解决Frozen Lake问题

最新推荐文章于 2024-05-22 17:52:23 发布
最新推荐文章于 2024-05-22 17:52:23 发布
阅读量6.4k 收藏 57
点赞数 12
分类专栏： Reinforcement Learning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/njshaka/article/details/89237941
版权

强化学习实战（一）：用值迭代和策略迭代解决Frozen Lake问题

1. Frozen Lake 问题

问题描述

    Winter is here. You and your friends were tossing around a frisbee at the park
    when you made a wild throw that left the frisbee out in the middle of the lake.
    The water is mostly frozen, but there are a few holes where the ice has melted.
    If you step into one of those holes, you'll fall into the freezing water.
    At this time, there's an international frisbee shortage, so it's absolutely imperative that
    you navigate across the lake and retrieve the disc.
    However, the ice is slippery, so you won't always move in the direction you intend.
    The surface is described using a grid like the following

        SFFF
        FHFH
        FFFH
        HFFG

    S : starting point, safe
    F : frozen surface, safe
    H : hole, fall to your doom
    G : goal, where the frisbee is located

    The episode ends when you reach the goal or fall in a hole.
    You receive a reward of 1 if you reach the goal, and zero otherwise.

2. 值迭代(Value Iteration)和策略迭代(Policy Iteration)

理论部分暂略

2.1 值迭代

2.1.1 伪代码

Value Iteration 伪代码

2.1.2 流程图

Created with Raphaël 2.2.0 开始 初始化随机值函数V(s) 对每个状态，计算Q(s,a) 因为贝尔曼最优方程终止 条件为V(s)=Max Q(s,a)， 故用Q(s,a)的最大值更新 值函数 V(s)最优？ 结束 yes no

2.2 策略迭代

2.2.1 伪代码

Policy Iteration 伪代码

2.2.2 流程图

Created with Raphaël 2.2.0 开始 初始化随机策略(Π) 计算该策略的值函数V(s) V(s)最优？ 结束 找到改进的策略 yes no

3. 代码实现

3.1 环境代码的一些解释

  1. 动作（action）：用数字0-3表示

    LEFT = 0
DOWN = 1
RIGHT = 2
UP = 3

  2. env.P[state][action]

    # 动作数 4
nA = 4
# 状态数 4*4=16
nS = nrow * ncol

P = {s : {a : [] for a in range(nA)} for s in range(nS)}

    P[][]本质上是一个“二维数组”，状态和动作分别由数字0-15和0-3表示。P[state][action]存储的是，在状态s下采取动作a获得的一系列数据，即(转移概率，下一步状态，奖励，完成标志)这样的元组。我们通过以下的代码更好的理解P[state][action]：

    P = {s : {a : [] for a in range(4)} for s in range(16)}
print(P)
P[1][1].append(('1','2','3','4'))
P[1][1].append(('a','b','c','d'))
for n in P[1][1]:
    a,b,c,d=n
print(a,b,c,d)
print(P)
print(P[1][1])

    输出：

    {0: {0: [], 1: [], 2: [], 3: []}, 1: {0: [], 1: [], 2: [], 3: []}, 2: {0: [], 1: [], 2: [], 3: []}, 3: {0: [], 1: [], 2: [], 3: []}, 4: {0: [], 1: [], 2: [], 3: []}, 5: {0: [], 1: [], 2: [], 3: []}, 6: {0: [], 1: [], 2: [], 3: []}, 7: {0: [], 1: [], 2: [], 3: []}, 8: {0: [], 1: [], 2: [], 3: []}, 9: {0: [], 1: [], 2: [], 3: []}, 10: {0: [], 1: [], 2: [], 3: []}, 11: {0: [], 1: [], 2: [], 3: []}, 12: {0: [], 1: [], 2: [], 3: []}, 13: {0: [], 1: [], 2: [], 3: []}, 14: {0: [], 1: [], 2: [], 3: []}, 15: {0: [], 1: [], 2: [], 3: []}}
a b c d
{0: {0: [], 1: [], 2: [], 3: []}, 1: {0: [], 1: [('1', '2', '3', '4'), ('a', 'b', 'c', 'd')], 2: [], 3: []}, 2: {0: [], 1: [], 2: [], 3: []}, 3: {0: [], 1: [], 2: [], 3: []}, 4: {0: [], 1: [], 2: [], 3: []}, 5: {0: [], 1: [], 2: [], 3: []}, 6: {0: [], 1: [], 2: [], 3: []}, 7: {0: [], 1: [], 2: [], 3: []}, 8: {0: [], 1: [], 2: [], 3: []}, 9: {0: [], 1: [], 2: [], 3: []}, 10: {0: [], 1: [], 2: [], 3: []}, 11: {0: [], 1: [], 2: [], 3: []}, 12: {0: [], 1: [], 2: [], 3: []}, 13: {0: [], 1: [], 2: [], 3: []}, 14: {0: [], 1: [], 2: [], 3: []}, 15: {0: [], 1: [], 2: [], 3: []}}
[('1', '2', '3', '4'), ('a', 'b', 'c', 'd')]

3.2 值迭代

import gym
import numpy as np

env = gym.make('FrozenLake-v0')
# 4*4的网格，有16个格子（状态），分别用0-15表示。eon=16
eon = env.observation_space.n
# 4个动作——上下左右，分别用0-3表示。ean=4
ean = env.action_space.n


# 值迭代
def value_itration(env, gamma=1.0):
    # 初始化状态值表（V表）
    value_table = np.zeros(eon)
    # 迭代次数
    no_of_iterations = 100000
    # 收敛判断阈值
    threshold = 1e-20
    # 开始迭代
    for i in range(no_of_iterations):
        # 初始化更新后的V表（旧表复制过来）
        updated_value_table = np.copy(value_table)
        # 计算每个状态下所有行为的next_state_rewards,并更新状态动作值表（Q表），最后取最大Q值更新V表
        # 遍历每个状态
        for state in range(eon):
            # 初始化存储Q值的列表
            Q_value = []
            # 遍历每个动作
            for action in range(ean):
                # 初始化存储下一个状态的奖励的列表
                next_states_rewards = []
                # P[][]是环境定义的变量,存储状态s下采取动作a得到的元组数据（转移概率，下一步状态，奖励，完成标志）
                for next_sr in env.P[state][action]:
                    # next_state是否是终止状态？if Yes：done=True；else：done=False
                    trans_prob, next_state, reward, done = next_sr
                    # 计算next_states_reward（公式）
                    next_states_rewards.append(
                        (trans_prob*(reward+gamma*updated_value_table[next_state])))
                    # 计算Q值（公式）
                    Q_value.append(np.sum(next_states_rewards))
                    # 取最大Q值更新V表，即更新当前状态的V值
                    value_table[state] = max(Q_value)

        # 收敛判断
        if(np.sum(np.fabs(updated_value_table-value_table)) <= threshold):
            print("Value-itration converged at itration # %d" % (i+1))
            break
    # 返回V表
    return value_table


# 策略选取
def extract_policy(value_table, gamma=1.0):
    # 初始化存储策略的数组
    policy = np.zeros(eon)
    # 对每个状态构建Q表，并在该状态下对每个行为计算Q值，
    for state in range(eon):
        # 初始化Q表
        Q_table = np.zeros(ean)
        # 对每个动作计算
        for action in range(ean):
            # 同上
            for next_sr in env.P[state][action]:
                trans_prob, next_state, reward, done = next_sr
                # 更新Q表，即更新动作对应的Q值（4个动作分别由0-3表示）
                Q_table[action] += (trans_prob *
                                    (reward+gamma*value_table[next_state]))
        # 当前状态下，选取使Q值最大的那个动作
        policy[state] = np.argmax(Q_table)
    # 返回动作
    return policy


# 最优值函数
optimal_value_function = value_itration(env=env, gamma=1.0)
# 最优策略
optimal_policy = extract_policy(optimal_value_function, gamma=1.0)

# 输出最优策略
print(optimal_policy)

3.3 策略迭代

# %%
import gym
import numpy as np

env = gym.make('FrozenLake-v0')
# 4*4的网格，有16个格子（状态），分别用0-15表示。eon=16
eon = env.observation_space.n
# 4个动作——上下左右，分别用0-3表示。ean=4
ean = env.action_space.n


# 计算值函数
def compute_value_function(policy, gamma=1.0):
    # 初始化V表
    value_table = np.zeros(eon)
    # 收敛判断阈值
    threshold = 1e-10
    # 循环直到收敛
    while True:
        # 初始化更新后的V表（旧表复制过来）
        updated_value_table = np.copy(value_table)
        # 计算每个状态从策略中得到的动作，然后计算值函数
        # 遍历每个状态
        for state in range(eon):
            # 根据策略取动作
            action = policy[state]
            # 更新该状态的V值（公式）
            value_table[state] = sum([trans_prob*(reward+gamma*updated_value_table[next_state])
                                      for trans_prob, next_state, reward, done in env.P[state][action]])
        # 收敛判断
        if (np.sum((np.fabs(updated_value_table-value_table))) <= threshold):
            break
    # 返回V表
    return value_table


# 策略选取（同上）
def extract_policy(value_table, gamma=1.0):
    # 初始化存储策略的数组
    policy = np.zeros(eon)
    # 对每个状态构建Q表，并在该状态下对每个行为计算Q值，
    for state in range(eon):
        # 初始化Q表
        Q_table = np.zeros(ean)
        # 对每个动作计算
        for action in range(ean):
            # 同上
            for next_sr in env.P[state][action]:
                trans_prob, next_state, reward, done = next_sr
                # 更新Q表，即更新动作对应的Q值（4个动作分别由0-3表示）
                Q_table[action] += (trans_prob *
                                    (reward+gamma*value_table[next_state]))
        # 当前状态下，选取使Q值最大的那个策略
        policy[state] = np.argmax(Q_table)
    # 返回策略
    return policy


# 策略迭代
def policy_iteration(env, gamma=1.0):
    # 初始化随机策略，下句代码即为初始策略全为0（向左走）
    random_policy = np.zeros(eon)
    # 设置迭代次数
    no_of_iterations = 200000
    # 开始迭代
    for i in range(no_of_iterations):
        # 计算新的值函数
        new_value_function = compute_value_function(random_policy, gamma)
        # 得到新的策略
        new_policy = extract_policy(new_value_function, gamma)
        # 判断迭代终止条件（策略不变时）
        if (np.all(random_policy == new_policy)):
            print('Policy-Iteration converged as step %d.' % (i+1))
            break
        # 新的策略为下一次的执行策略
        random_policy = new_policy
    # 返回新的策略
    return new_policy


# 输出最优策略
print(policy_iteration(env))

Tips:

random_policy = np.zeros(eon)

更改为

random_policy = np.ones(eon)

即初始策略全为1（向下走），收敛更快！当然，设置为0-3之间的随机数也是可以的，

random_policy = np.random.randint(0,3,(eon))+0.0

4. Reference

[1] http://gym.openai.com/
[2] Reinforcement Learning: An Introduction (2018)
[3] Hands-On Reinforcement Learning with Python: Master reinforcement and deep reinforcement learning using OpenAI Gym and TensorFlow [M]

敬请批评指正！

MADRLer
关注
  • 12
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
frozen-lake:在游戏《冰湖》中测试的Q学习算法
05-25
Q学习的冰冻湖 Q-Learning算法已在游戏《冰湖》中进行测试。 技术 该项目是通过使用nodejs和electronic的javascript实现的。 这个怎么运作 该游戏与gym.openai 相同 在这个游戏中，特工必须经过抽签才能达到目标“ G”并获得1分的奖励，否则将不给予奖励。 它可以从四个要在环境中执行的动作中进行选择，这些动作是：左移，右移，向上和向下。 字母“ S”是安全的起始位置，字母“ F”是冻结的表面，也很安全。 如果特工发现一个“ H”洞，它将掉落，结束游戏并开始下一个情节。 由于湖的表面被冻结了，特工有机会滑倒并滑到不想去的位置。 结果 通过项目中使用的参数，获得了Q表。 这是最终的Q表，代表了座席在培训阶段所获得的经验。 每一列都是业务代表根据状态可立即获得以及将来获得的奖励（向左，向右，向上和向下）采取该行动的概率。 正如所言。 而且每
动态规划/Q学习算法解决Frozenlake问题
06-07
北邮强化学习期中大作业，分别使用价值迭代、策略迭代以及Q学习解决gym的Frozenlake问题，包含相关源码以及算法说明文档。
利用q-learning强化学习方法实现gym的Frozen_Lake游戏环境的学习（附上详细的代码资料）
weixin_50233916的博客
07-18 802
最近在研究强化学习相关的内容，浏览网站，发现大多都是关于gym 的 env 环境搭建过程的，而对强化学习的算法构建环节只字不提。没办法，笔者研究只好研究相关资料，自行学习并构建了Q-learning算法下运用gym库进行强化学习的程序框架。目前能够完成基础的强化学习任务。 在本次实践中，我们着手研究gym的环境搭建和环境frozen_lake的源程序结构，在了解其游戏规则和回报计算方式 的基础上，尝试自行构建Q-learning强化学习算法并将其运用到该游戏问题中。
强化学习第四章：值迭代与策略迭代
最新发布
qq_42828479的博客
05-22 641
根据Contraction Papping Theorem，迭代一定次数之后求解出最优策略和最优状态价值。在值迭代和策略迭代算法对比的具体分析的第四步可以看到，值迭代只算一次，策略迭代理论是无数次。那么折中一点的方法就是截断策略迭代算法。
分别使用策略迭代、价值迭代以及Q学习算法解决gym的冰湖问题.zip
09-29
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 适用工作项目、毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，轻松复刻，欢迎下载 -------- 下载后请首先打开README.md文件（如有），仅供学习参考。
FrozenLake中的值迭代和策略迭代举例【代码】
June
06-06 1081
值迭代 import numpy as np import gym # render()是图像引擎，无参数 # step()是物理引擎，输入参数为动作 # 迭代运行 episode def run_episode(env, policy, gamma = 1.0, render = False): """ Evaluates policy by using it to run an episode and finding its total reward. args:自变量
Policy Iteration与Value Iteration
gy77
01-21 1216
gym环境：FrozenLake-v0：http://gym.openai.com/envs/FrozenLake-v0/ 代码来自：周博磊老师的GitHub：https://github.com/cuhkrlcourse/RLexample/tree/master/MDP 环境如下： SFFF (S: starting point, safe) FHFH (F:...
【强化学习】04 ——动态规划算法
sinat_52032317的博客
09-29 811
动态规划）是程序设计算法中非常重要的内容，能够高效解决一些经典问题，例如背包问题和最短路径规划。动态规划的基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到目标问题的解。最优子结构：最优解可以被分解为子问题。最优性原理适用：重叠子问题：子问题经常重复出现。解决方案可以被缓存和重复使用。马尔可夫决策过程符合这两个属性。贝尔曼方程提供了递归分解。价值函数存储和重用解决方案。基于动态规划的强化学习算法主要有两种：一是策略迭代。
gym FrozenLake 理解学习
power的专栏
03-07 2884
0 左 1下 2右 3 上 奖励： 稀疏奖励， 全0，当到达目标奖励为1。 终止：到达目标或者到达H >>> import gym >>> env = gym.make( "FrozenLake-v0", is_slippery=False) >>> env.reset() 0 >>> env.render() SFFF FHFH FFFH HFFG >>> env.step(0) (...
frozenlake_policy_interation_FrozenLake_强化学习：策略迭代程序_强化学习_
09-30
强化学习和策略迭代的应用远不止于解决FrozenLake问题，它们在机器人控制、游戏AI、资源管理等众多领域都有广泛的应用。理解并能够实现策略迭代是强化学习研究者和开发者的基本技能之一，它可以帮助智能体在未知环境...
frozen-lake:许多用于网格世界变体方案的强化学习算法
04-22
自述文件 如果您安装了pipenv，则我们提供了一个pipfile。...策略迭代 冰冻的湖面环境 价值迭代 Sarsa控制 Q学习 Sara控制+线性函数逼近 Q学习控制+线性函数逼近 否则，请确保通过pip install numpy 。
12、策略评估在FrozenLake中的实现1
08-04
在强化学习中，策略评估是计算给定策略值函数的过程，它是策略迭代和价值迭代算法的基础。本节我们将深入理解并探讨如何在Python环境中，特别是使用gym库的FrozenLake-v0环境，来实现策略评估算法。 策略评估的目的...
强化学习实践（一）基于MDP策略迭代计算Frozenlake问题
qq_42256930的博客
08-09 706
1、策略迭代代码 #use Policy Iteration to solve Frozenlake problem import numpy as np import gym # Runs an episode and return the total reward def Run_episode(env, policy, gamma = 1.0, render = False): obs = env.reset() total_reward = 0 step_idx = 0
强化学习之策略迭代和价值迭代(gym)
SL_World的博客
08-11 3512
前言 —— 基于动态规划的强化学习 一、策略迭代 1.1 伪代码 1.2 基于冰湖环境的代码 实验环境及介绍：FrozenLake8x8-v0 import gym import time import numpy as np def policy_evaluation(env, value_table, policy, gamma=0.9, threshold=1e-4): delta = 2 * threshold while delta > threshold:
强化学习之策略迭代求解冰冻湖
zhf的博客
03-15 996
理论回顾 [1]. Bellman方程求解 [2]. 3.12 Value Iteration - Frozen Lake Problem.ipynb [3]. 强化学习中马尔科夫决策过程和贝尔曼方程 [4]. 强化学习之值迭代求解冰冻湖 ''' 策略迭代求解冰冻湖 ''' """ 冰冻湖，其中，S是起始位置 F是可通过的冰冻湖 H是必须小心的洞 G是目标 S F F F F...
强化学习-Q-learning FrozenLake-V0 实现
zjjtilm的博客
06-26 4363
DQN算法是QLearning算法的延伸，在大多数实际场景中，Q值表的状态空间会很大，构建Q值表的方式就不太行得通，因此通过引入神经网络来学习拟合状态空间，解决状态空间过大而不方便维护更新Q值表的问题。 首先定义一个Agent类，sample函数就是使用epsilon-greedy的采样方法，predict则是根据当前的观察值来预测输出的动作，learn就是通过输入当前的观察值obs,当前的动作action，奖励reward以及下一个时刻的观察值next_obs来更新Q值表。 代码： class Q
【Tensorlayer系列】深度强化学习之DQN求解FrozenLake
松间沙路的博客
03-06 4441
获取更多资讯，赶快关注上面的公众号吧！ Tensorlayer深度强化学习系列： Tensorlayer深度强化学习之Tensorlayer安装 【Tensorlayer系列】深度强化学习之FrozenLake介绍及表格型Q学习求解 文章目录3.1 FrozenLake-v03.2 DQN3.2.1 代码3.2.2 实验结果 3.1 FrozenLake-v0 FrozenLake环境的介绍可...
强化学习用 Sarsa 算法与 Q-learning 算法实现FrozenLake-v0
waitingwinter的博客
05-23 4558
基础知识 关于Q-learning 和 Sarsa 算法, 详情参见博客 需要注意的细节 训练时 采用 ϵ\epsilonϵ 贪心算法; # 贪婪动作选择，含嗓声干扰 a = np.argmax(Q_all[s, :] + np.random.randn(1, env.action_space.n) * (1. / (i + 1))) 对 Q-learning 算法 # 更新Q表 # Q-learning Q_all[s, a] = Q_all[s, a] + alpha * (r + gamma
2.4 FrozenLake使用cross-entropy方法
cxw的博客
01-12 675
FrozenLake是gym的另一个grid world环境。其环境简单的栅格地图，有四种栅格状态，分别用字母SFHG表示，下面是一个地图的例子： SFFF (S: starting point, safe) FHFH (F: frozen surface, safe) FFFH (H: hole, fall to your doom) HFFG (G: goal, where the frisbee is located) ...
值迭代和策略迭代是强化学习方法 吗
07-14
是的，值迭代和策略迭代都是强化学习中的经典方法。 值迭代（Value Iteration）是一种基于值函数的迭代算法。它通过反复更新状态值函数来找到最优策略。在每次迭代中，值迭代算法会根据当前状态值函数计算出每个状态的最优动作值，然后更新状态值函数。这个过程会一直进行，直到收敛到最优值函数。 策略迭代（Policy Iteration）是一种同时优化策略和值函数的迭代算法。它通过交替进行策略评估和策略改进来找到最优策略。在每次迭代中，策略迭代算法首先根据当前策略评估状态值函数，然后根据当前状态值函数改进策略。这个过程会一直进行，直到收敛到最优策略和最优值函数。 这两种方法都是强化学习中常用的方法，用于解决马尔可夫决策过程（Markov Decision Process, MDP）中的最优控制问题。它们在理论上都能收敛到最优解，但在实际应用中可能存在一些差异和适用性的考虑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值