Monte Carlo方法解决强化学习问题

本文涉及的产品
实时数仓Hologres,5000CU*H 100GB 3个月
检索分析服务 Elasticsearch 版,2核4GB开发者规格 1个月
实时计算 Flink 版,5000CU*H 3个月
简介: 本文继续深入探讨蒙特卡罗 (MC)方法。这些方法的特点是能够仅从经验中学习,不需要任何环境模型,这与动态规划(DP)方法形成对比。

本文继续深入探讨蒙特卡罗 (MC)方法。这些方法的特点是能够仅从经验中学习,不需要任何环境模型,这与动态规划(DP)方法形成对比。

这一特性极具吸引力 - 因为在实际应用中,环境模型往往是未知的,或者难以精确建模转移概率。以21点游戏为例:尽管我们完全理解游戏规则,但通过DP方法解决它将极为繁琐 - 因为需要计算各种条件概率,例如给定当前已发牌的情况下,"21点"出现的概率,再抽到一张7的概率等。而通过MC方法,可以绕过这些复杂计算,直接从游戏体验中学习。

由于不依赖模型,MC方法是无偏的。它们在概念上简单明了,易于理解,但表现出较高的方差,且不能采用迭代方式求解(即无法进行自举)。

本文结构如下:首先介绍MC方法和"预测"问题,接着我们讨论"控制"问题。将展示一个基于两个(不太实际的)假设的初始MC控制算法:我们将观察到无限多的情节,且每个状态-动作对将被访问无限多次(探索性启动)。

文章的后半部分将讨论如何移除这些假设:第一个假设相对容易处理,但后者需要更多考虑。我们首先介绍一种on-policy方法,其中最优策略保持ε-greedy,然后转向涉及重要性采样的off-policy方法。

Monte Carlo预测

我们首先讨论预测问题 - 即估计给定策略的价值函数。MC方法的核心思想是采样情节,收集并平均跟随状态的回报来计算价值函数 - 在极限情况下,这将收敛到期望值。这一原理是所有MC方法的共同特征,也是这类方法名称的由来(因Monte Carlo地区赌博盛行而得名)。

我们可以定义两种略有不同的计算平均值的方法:首次访问MC方法和每次访问MC方法。在生成情节时,某个状态可能被多次访问。首次访问MC方法仅对第一次出现后的回报进行平均来估计状态的值,而每次访问MC方法对所有访问后的回报进行平均。这两种方法具有略微不同的理论特性,但本文我们将主要关注首次访问MC。其伪代码如下:

这种方法在当前情境下并非最优:在基于模型的方法中,当估计价值函数时,可以对任何状态探索所有可能的动作,然后选择导向最高价值状态的动作。在无模型的情况下,估计状态-动作对的值(即动作-价值函数)更为合适。这可以按照上面为价值函数所示的方式进行,但存在一个关键问题:很可能有些状态-动作对从未被访问过,没有结果可以平均,导致其价值估计无法改善。

这会涉及到探索-利用权衡的问题,以及如何持续保持探索。一个保证这一点的假设是在随机状态/动作组合中开始每个情节,并要求所有动作都有非零概率被选择。这被称为探索性启动假设。我们将在下一节MC控制中结合其实现。

Monte Carlo控制

与动态规划文章中一样,我们将使用广义策略迭代(GPI) - 策略评估和策略改进的迭代步骤。

这个过程本身在这里并无特别之处 - 除了我们必须做两个(不太实际的)假设才能使其工作:我们需要探索性启动的假设,并且要求策略评估的内部循环进行无限多步。

后一个假设可以相对容易地移除:允许提前终止策略评估循环是可以的,只需让策略的值更接近最优值而不必达到它 。

目前,我们将保留探索性启动假设,并展示一个基于此假设的控制算法 - 在文章的最后部分,我们将展示如何移除这个假设。

带有探索性启动的Monte Carlo控制

以下是带有探索性启动(ES)的MC控制的伪代码:

现在让我们将其转换为Python代码:

这里遇到的第一个挑战是如何保证ES假设:gymnasium [2]和一般的RL环境并不设计用于跳转到任意状态。我们初始化环境,然后从初始状态开始行动(例如,一个问题是历史信息:如果跳转到随机状态,如何生成可能需要的历史帧?)。

也许可以修改gymnasium,或实现允许生成随机状态的自定义环境,但这里实现一个函数来生成环境的几个可能状态,然后从这个列表中采样。

这个函数会被多次调用(对每个生成的情节),所以我们希望缓存这个计算成本高的生成过程。我在测试时发现functools.lrucache装饰器在确定gymnasium环境的相等性时存在问题,所以自己实现了一个自定义缓存装饰器,忽略第一个(环境)参数(另一个选择是重写环境的equals方法):

 defcall_once(func):  
     """自定义缓存装饰器
     忽略第一个参数。
     """  
     cache= {}  

     defwrapper(*args, **kwargs):  
         key= (func.__name__, args[1:])  
         assertnotkwargs, "We don't support kwargs atm"  
         ifkeynotincache:  
             cache[key] =func(*args)  
         returncache[key]  

     returnwrapper  


 @call_once  
 defgenerate_possible_states(  
     env: ParametrizedEnv, num_runs: int=100  
 ) ->list[tuple[int, ParametrizedEnv]]:  
     """生成环境的可能状态。
     为此,通过选择随机状态并从该状态开始
     遵循随机策略,记录新状态,
     迭代地增加已知状态集。

     Args:  
         env: 使用的环境  
         num_runs: 发现循环的次数  

     Returns:  
         包含发现状态的列表 - 这些是状态(观察)
         和表示该状态的gym环境的元组  
     """  
     _, action_space=get_observation_action_space(env)  

     observation, _=env.env.reset()  
     possible_states= [(observation, copy.deepcopy(env))]  

     for_inrange(num_runs):  
         observation, env=random.choice(possible_states)  
         env=copy.deepcopy(env)  
         terminated=truncated=False  
         whilenotterminatedandnottruncated:  
             action=np.random.choice([aforainrange(action_space.n)])  
             observation, _, terminated, truncated, _=env.env.step(action)  
             ifobservationinset([stateforstate, _inpossible_states]):  
                 break  
             else:  
                 ifnotterminatedandnottruncated:  
                     possible_states.append((observation, env))  

     returnpossible_states  


 defgenerate_random_start(env: ParametrizedEnv) ->tuple[int, ParametrizedEnv]:  
     """选择一个随机起始状态。
     为此,首先生成所有可能的状态(缓存),
     然后从这些状态中随机选择一个。
     """  
     possible_states=generate_possible_states(env)  
     observation, env=random.choice(possible_states)  
     returncopy.deepcopy(observation), copy.deepcopy(env)

这个

generate_possible_states

函数迭代地构建一组可能的状态:它首先从已知状态中选择一个,然后遵循随机动作,同时记录所有新状态。

另外还实现了一个辅助函数来生成遵循特定策略的情节:

 defgenerate_episode(  
     env: ParametrizedEnv,  
     pi: np.ndarray,  
     exploring_starts: bool,  
     max_episode_length: int=20,  
 ) ->list[tuple[Any, Any, Any]]:  
     """生成一个遵循给定策略的情节。

     Args:  
         env: 使用的环境  
         pi: 要遵循的策略  
         exploring_starts: 当为True时遵循探索性启动假设(ES)  

     Returns:  
         生成的情节  
     """  
     _, action_space=get_observation_action_space(env)  

     episode= []  

     observation, _=env.env.reset()  

     ifexploring_starts:  
         # 如果是ES,选择随机起始状态  
         observation, env=generate_random_start(env)  

     terminated=truncated=False  
     initial_step=True  

     whilenotterminatedandnottruncated:  
         ifinitial_stepandexploring_starts:  
             # 如果是ES,初始时选择随机动作  
             action=np.random.choice([aforainrange(action_space.n)])  
         else:  
             action=np.random.choice(  
                 [aforainrange(action_space.n)], p=pi[observation]  
             )  
         initial_step=False  

         observation_new, reward, terminated, truncated, _=env.env.step(action)  

         episode.append((observation, action, reward))  

         # 终止智能体陷入死循环的情节  
         iflen(episode) >max_episode_length:  
             break  

         observation=observation_new  

     returnepisode

当使用ES调用时,第一个动作选择是完全随机的 - 否则在每一步根据策略分布采样动作。提前终止"陷入死循环"的情节很重要:由于在MC方法中完整地执行情节并且只在之后更新策略,可能会发生策略陷入某个非理想动作导致循环访问序列的情况(例如,在左上角不断向左转 - 这个动作没有任何实际效果)。为了避免无限等待(或直到环境自行终止),我们需要在达到一定步数后主动中断。

有了这些辅助函数,就可以可以实现上面介绍的MC ES算法:

 defmc_es(env: ParametrizedEnv) ->np.ndarray:  
     """通过带有探索性启动的Monte Carlo方法
     求解传入的Gymnasium环境。

     Args:  
         env: 包含问题的环境  

     Returns:  
         找到的策略  
     """  
     observation_space, action_space=get_observation_action_space(env)  

     pi= (  
         np.ones((observation_space.n, action_space.n)).astype(np.int32) /action_space.n  
     )  
     Q=np.zeros((observation_space.n, action_space.n))  

     returns=defaultdict(list)  
     num_steps=1000  

     fortinrange(num_steps):  
         episode=generate_episode(env, pi, True)  

         G=0.0  
         fortinrange(len(episode) -1, -1, -1):  
             s, a, r=episode[t]  
             G=env.gamma*G+r  
             prev_s= [(s, a) for (s, a, _) inepisode[:t]]  
             if (s, a) notinprev_s:  
                 returns[s, a].append(G)  
                 Q[s, a] =statistics.fmean(returns[s, a])  
                 ifnotall(Q[s, a] ==Q[s, 0] forainrange(action_space.n)):  
                     forainrange(action_space.n):  
                         pi[s, a] =1ifa==np.argmax(Q[s]) else0  

     returnnp.argmax(pi, 1)

从Python代码到上面的伪代码的映射应该相对直观 - 但需要做一个重要的补充,即在更新策略之前进行相等性检查:在生成情节时可能没有遇到非零奖励,所以策略更新最初会在缺乏信息的情况下最大化某个动作。

无探索性启动的Monte Carlo控制

上面我们已经看到了一个基于ES假设的初始MC控制方法。但这种方法在实际应用中存在局限性 - 因此在后面部分,我们将介绍两种不依赖这个假设的方法。

总的来说,为了使这些方法有效,必须确保所有状态-动作对都能被无限次探索(*),有两类方法可以帮助我们实现这一点:on-policy方法和off-policy方法。On-policy方法试图改进生成数据的策略,而off-policy方法可以改进目标策略,同时从不同的行为策略生成数据。

这里我们首先介绍一个on-policy方法,然后再介绍一个off-policy方法。到目前为止我们考虑的所有方法都是on-policy方法,因为只涉及一个策略 - 我们用它来生成数据,同时也直接优化它。为了在on-policy方法中满足条件(*),核心思想是保持策略"软性",而不是像我们在上面做的那样进行"硬性"更新。也就是说,当更新策略朝向最大

Q

值的动作时,我们不会直接转向确定性策略,而是仅仅朝着这样一个确定性策略移动,同时保持

对于所有状态和动作成立。

除此之外,与上面介绍的MC ES算法没有太大区别,结构上的相似性应该很明显:

Python实现:

 defon_policy_mc(env: ParametrizedEnv) ->np.ndarray:  
     """通过on-policy Monte Carlo控制方法
     求解传入的Gymnasium环境。

     Args:  
         env: 包含问题的环境  

     Returns:  
         找到的策略  
     """  
     observation_space, action_space=get_observation_action_space(env)  

     pi= (  
         np.ones((observation_space.n, action_space.n)).astype(np.int32) /action_space.n  
     )  
     Q=np.zeros((observation_space.n, action_space.n))  

     returns=defaultdict(list)  
     num_steps=1000  

     for_inrange(num_steps):  
         episode=generate_episode(env, pi, False)  

         G=0.0  
         fortinrange(len(episode) -1, -1, -1):  
             s, a, r=episode[t]  
             G=env.gamma*G+r  
             prev_s= [(s, a) for (s, a, _) inepisode[:t]]  
             if (s, a) notinprev_s:  
                 returns[s, a].append(G)  
                 Q[s, a] =statistics.fmean(returns[s, a])  
                 ifnotall(Q[s, a] ==Q[s, 0] forainrange(action_space.n)):  
                     A_star=np.argmax(Q[s, :])  
                     forainrange(action_space.n):  
                         pi[s, a] = (  
                             1-env.eps+env.eps/action_space.n  
                             ifa==A_star  
                             elseenv.eps/action_space.n  
                         )  

     returnnp.argmax(pi, 1)

Off-Policy Monte Carlo控制

要介绍off-policy方法,我们需要更深入的讨论。这类方法的提出源于在on-policy方法中所做的折衷:希望学习一个最优策略,但同时还必须保持探索。到目前为止介绍的on-policy方法正是解决了这样一个折衷:它们学习一个近似最优的策略,该策略仍然保持一定程度的探索。使用两个策略似乎更为直观:优化一个目标策略,同时使用另一个策略来探索和生成数据。

正是由于这个原因,off-policy方法实际上更加通用和强大(一些最著名的RL算法,如Q-Learning,都是off-policy方法) - 但它们通常具有更高的方差,收敛速度也较慢。

大多数off-policy方法的共同特点是使用重要性采样:因为我们想计算目标策略的期望,但实际上是从不同的策略采样,所以直接计算的期望是有偏的。重要性采样通过适当地缩放观察到的值,使得得到的估计重新变得无偏。由于篇幅限制,这里不做更详细的介绍。

要将这应用于强化学习,我们再次从预测问题开始。首先看一下遵循策略π时状态-动作轨迹出现的概率:

现在我们引入两个策略:π是我们的目标策略,即我们想要优化的策略,

b

是我们的行为策略 - 用于生成数据的策略。我们需要满足覆盖性假设:如果在π下可能采取某个动作,那么在

b

下该动作也必须有非零概率 - 这意味着

b

需要在与π不同的状态下是一个随机策略。

接下来计算轨迹在π和

b

下出现的概率比:

值得注意的是,环境本身的任何属性,如状态转移概率都被约掉了,只剩下策略比率。

所以需要这个比率来进行off-policy预测,因为我们想从

b

收集的数据中估计策略π的值 - 这意味着直接计算的期望

会是有偏的。但是,通过重要性采样可以修正这个偏差:

具体应用到RL预测问题得到:

这个形式应该看起来很熟悉:一个状态的预测值只是(重要性采样修正的)平均回报(除以用于计算期望的状态数 - 这是典型的Monte Carlo期望估计)。

但对于我们的算法,实际上会使用加权重要性采样:

也就是说,它在分母中也包含了重要性采样权重,即计算加权平均值(注意分子和分母的权重通常不会相互抵消,因为它们出现在求和中)。

如果我们只观察到一个回报,加权重要性采样的权重会相互抵消。期望会是有偏的(它会得出

v_b

),但这似乎是合理的,因为我们只观察到这一个样本。对于普通重要性采样,期望总是无偏的,但它可能会非常极端 - 例如,想象重要性采样权重是10或100。总的来说,加权重要性采样是有偏的(尽管随着样本数增加,偏差趋向于0),但比普通重要性采样具有更低的方差,后者可能具有无界(无限)方差。

回到off-policy MC预测,我们想要形成的估计是:

理论上,可以在每一步单独计算这个测量值 - 也就是保留一个权重和回报的列表并计算相应的值。

但是我们可以引入一种增量方法来节省内存。在这种方法中只需要存储先前的估计,并使用新值来更新它

此外还需要保持对迄今为止累积权重的运行估计:

乍看之下,可能不太明显这些公式确实是加权重要性采样的增量版本。但它们是正确的。在这里省略了证明以保持文章的简洁,并且因为我认为它对理解核心概念并不是至关重要的。但是我们这里想象一个更简单的,非增量版本的这个算法可能有助于理解。

使用这个增量更新方案,MC off-policy预测算法如下:

转到off-policy MC控制算法:

我们看到完全相同的重要性采样更新模式,只是现在还更新了一个策略。注意上面的

W != 0

检查现在被"break"替代,只要选择的动作不对应于π(这意味着

W = 0

,因为π是确定性的)。出于同样的原因,更新规则也是

1/b(…)

而不是

π(…)/b(…)

这个算法可以直接翻译成Python代码:

 defoff_policy_mc(env: ParametrizedEnv) ->np.ndarray:  
     """通过off-policy Monte Carlo控制方法
     求解传入的Gymnasium环境。

     Args:  
         env: 包含问题的环境  

     Returns:  
         找到的策略  
     """  
     observation_space, action_space=get_observation_action_space(env)  

     Q=np.zeros((observation_space.n, action_space.n))  
     C=np.zeros((observation_space.n, action_space.n))  
     pi=np.argmax(Q, 1)  

     num_steps=1000  

     for_inrange(num_steps):  
         b=np.random.rand(int(observation_space.n), int(action_space.n))  
         b=b/np.expand_dims(np.sum(b, axis=1), -1)  

         episode=generate_episode(env, b, False)  

         G=0.0  
         W=1  
         fortinrange(len(episode) -1, -1, -1):  
             s, a, r=episode[t]  
             G=env.gamma*G+r  
             C[s, a] +=W  
             Q[s, a] +=W/C[s, a] * (G-Q[s, a])  
             pi=np.argmax(Q, 1)  
             ifa!=np.argmax(Q[s]):  
                 break  
             W*=1/b[s, a]  

     returnpi

我们将展示一个增量算法的"更简单"和更直观的版本 - 将实现"纯"重要性采样,而不使用增量更新。这有助于理解,它清晰地展示了重要性采样是如何真正使用的,一步一步地形成所有需要的项:

 defoff_policy_mc_non_inc(env: ParametrizedEnv) ->np.ndarray:  
     """通过on-policy MonteCarlo控制方法求解传入的Gymnasium环境 - 
     但不使用Sutton的增量算法来更新重要性采样权重。

     Args:  
         env: 包含问题的环境  

     Returns:  
         找到的策略  
     """  
     observation_space, action_space=get_observation_action_space(env)  

     Q=np.zeros((observation_space.n, action_space.n))  

     num_steps=10000  
     returns=defaultdict(list)  
     ratios=defaultdict(list)  

     for_inrange(num_steps):  
         b=np.random.rand(int(observation_space.n), int(action_space.n))  
         b=b/np.expand_dims(np.sum(b, axis=1), -1)  

         episode=generate_episode(env, b, False)  

         G=0.0  
         ratio=1  
         fortinrange(len(episode) -1, -1, -1):  
             s, a, r=episode[t]  
             G=env.gamma*G+r  

             # 创建当前目标策略,
             # 它是Q函数的argmax,
             # 但对于Q值相等的情况给予相等的权重
             pi=np.zeros_like(Q)
             pi[np.arange(Q.shape[0]), np.argmax(Q, 1)] =1
             uniform_rows=np.all(Q==Q[:, [0]], axis=1)
             pi[uniform_rows] =1/action_space.n

             ratio*=pi[s, a] /b[s, a]
             ifratio==0:
                 break

             returns[s, a].append(G)
             ratios[s, a].append(ratio)

             Q[s, a] =sum([r*sforr, sinzip(returns[s, a], ratios[s, a])]) /sum(
                 [sforsinratios[s, a]]
             )

     Q=np.nan_to_num(Q, nan=0.0)

     returnnp.argmax(Q, 1)

更深入地分析这个实现,的目标是收集并平均所有状态-动作对的回报 - 不同之处在于这里我们使用every-visit MC而不是first-visit MC(因此没有检查该对是否已经在情节中出现过)。因此通过生成情节并平均收集的回报来构建

Q

函数 - 这里也不是简单地平均,而是使用(加权)重要性采样,所以需要计算的量是:

集合τ表示访问状态

s

的所有时间步 - 对于first-visit MC,它只包括首次访问

s

的所有时间步(使用状态-动作对)。忽略重要性采样权重,这个公式将得到与MC ES完全相同的结果 - 对于状态的每次出现,我们收集其相应的回报

G_t

,并取平均值。现在,还需要重要性采样权重s来修正我们的有偏估计。这些权重是:

因此,除了跟踪每个访问的状态-动作对的回报之外,还用这个量填充ratios。为了生成它,当反向遍历一个情节时,我们迭代地计算

p_{T-1:T-1}

p_{T-2:T-1}

等,并将这个运行计算存储在

ratio

中 - 在每一步都将其附加到ratios中。即时计算当前目标策略π以估计正确的权重 - 它只是从当前

Q

获得的确定性策略。

这种方法是有效的(就像所有其他方法一样),但它需要大约10倍的情节数才能保证收敛,相比增量off-policy MC控制算法而言 - 这是非常奇怪的。我的理解是在这里只是实现了一个具有完全相同功能的非增量版本。所以这个额外的实现能更清楚地说明off-policy MC控制是如何工作的,但是并不能在实际应用中保证快速的运行。如果您有任何问题、评论或建议/解决方案 - 特别是关于为什么结果会有差异 - 请随时让我知道!

总结

MC方法的独特之处在于它们仅从经验中学习,不需要环境模型 - 这为解决复杂问题提供了令人兴奋的可能性。

我们首先介绍了一个基于探索性启动(ES)假设的MC控制算法 - 即每个状态-动作对都以非零概率被无限探索。之后,我们尝试移除ES假设 - 最后,我们还提供了一个非增量off-policy MC控制算法的实现 - 这可能有助于更深入地理解算法的工作原理,并展示了如何以直观的方式实现off-policy MC控制,而不需要任何优化技巧。

参考文献

[1] Sutton, R. S., & Barto, A. G. (2018). Reinforcement learning: An introduction. MIT press. http://incompleteideas.net/book/RLbook2020.pdf 注:公式都是从这里截图的

[2] Farama Foundation. (2022). Gymnasium: A Python Library for Reinforcement Learning Environments. https://github.com/Farama-Foundation/Gymnasium

https://avoid.overfit.cn/post/400bebe168ab407e95c73580c331f6da

作者:Oliver S

目录
相关文章
|
机器学习/深度学习 存储 算法
【强化学习】常用算法之一 “DQN”
DQN算法是深度学习领域首次广泛应用于强化学习的算法模型之一。它于2013年由DeepMind公司的研究团队提出,通过将深度神经网络与经典的强化学习算法Q-learning结合,实现了对高维、连续状态空间的处理,具备了学习与规划的能力。本文对DQN算法进行了详细的讲解,包括发展史、算法公式和原理、功能、示例代码以及如何使用。DQN算法通过结合深度学习和Q-learning算法,实现了对高维、连续状态空间的处理,具备了学习和规划的能力。
1534 0
【强化学习】常用算法之一 “DQN”
|
5月前
|
机器学习/深度学习 数据采集 算法
Machine Learning机器学习之K近邻算法(K-Nearest Neighbors,KNN)
Machine Learning机器学习之K近邻算法(K-Nearest Neighbors,KNN)
|
5月前
|
数据可视化 Python
R语言蒙特卡罗Monte Carlo方法进行数值积分和模拟可视化
R语言蒙特卡罗Monte Carlo方法进行数值积分和模拟可视化
|
5月前
|
算法 数据可视化 Windows
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(2)
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(2)
|
5月前
|
算法 数据可视化 数据挖掘
Python Monte Carlo K-Means聚类实战研究
Python Monte Carlo K-Means聚类实战研究
|
5月前
|
算法 数据可视化
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(1)
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(1)
|
5月前
|
算法 数据可视化
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(上)
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样
|
5月前
|
算法 数据可视化 Windows
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样(下)
R语言BUGS/JAGS贝叶斯分析: 马尔科夫链蒙特卡洛方法(MCMC)采样
|
机器学习/深度学习 算法 自动驾驶
【强化学习】常用算法之一 “PPO”
强化学习是一种通过智能体与环境的互动来学习最优行为策略的机器学习方法。相较于监督学习和无监督学习,强化学习的特点在于具有延迟奖赏和试错机制。在强化学习中,智能体通过选择动作来影响环境,并且从环境中获得奖励作为反馈。强化学习的目标是通过与环境的交互,使得智能体能够学会最优的行为策略。PPO算法属于策略优化(Policy Optimization)算法家族,是由OpenAI在2017年提出的。与其他策略优化算法相比,PPO算法具有较高的样本利用率和较好的收敛性能。
1206 1
【强化学习】常用算法之一 “PPO”
|
机器学习/深度学习 算法 安全
基于时态差分法的强化学习:Sarsa和Q-learning
时态差分法(Temporal Difference, TD)是一类在强化学习中广泛应用的算法,用于学习价值函数或策略。Sarsa和Q-learning都是基于时态差分法的重要算法,用于解决马尔可夫决策过程(Markov Decision Process, MDP)中的强化学习问题。
172 1