强化学习 - Trust Region Policy Optimization (TRPO)

最新推荐文章于 2024-03-22 18:45:34 发布
最新推荐文章于 2024-03-22 18:45:34 发布
阅读量758 收藏 13
点赞数 20
分类专栏： 数据结构与算法 文章标签： 机器学习 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/galoiszhou/article/details/135742696
版权

什么是机器学习

Trust Region Policy Optimization（TRPO）是一种策略梯度方法，用于解决强化学习问题。TRPO旨在通过限制策略更新的大小，提高训练的稳定性。这样可以防止在参数空间中迅速迭代导致过大的更新，从而保持策略在相邻状态上的相似性。

以下是一个使用 Python 和 TensorFlow/Keras 实现简单的 TRPO 的示例。在这个例子中，我们将使用 OpenAI Gym 的 CartPole 环境。

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
import gym

# 定义TRPO Agent
class TRPOAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.gamma = 0.99  # 折扣因子
        self.lmbda = 0.95  # GAE（Generalized Advantage Estimation）的参数
        self.learning_rate = 0.001
        self.clip_ratio = 0.2

        # 构建演员（Actor）网络
        self.actor = self.build_actor()

    def build_actor(self):
        state_input = Input(shape=(self.state_size,))
        dense1 = Dense(64, activation='tanh')(state_input)
        dense2 = Dense(64, activation='tanh')(dense1)
        output = Dense(self.action_size, activation='softmax')(dense2)
        model = Model(inputs=state_input, outputs=output)
        model.compile(loss=self.trpo_loss, optimizer=Adam(lr=self.learning_rate))
        return model

    def get_action(self, state):
        state = np.reshape(state, [1, self.state_size])
        action_prob = self.actor.predict(state)[0]
        action = np.random.choice(self.action_size, p=action_prob)
        return action, action_prob

    def trpo_loss(self, y_true, y_pred):
        advantage = tf.placeholder(tf.float32, shape=(None, 1))
        old_policy_prob = tf.placeholder(tf.float32, shape=(None, self.action_size))
        new_policy_prob = y_pred

        ratio = tf.exp(tf.log(new_policy_prob + 1e-10) - tf.log(old_policy_prob + 1e-10))
        surrogate_loss = -tf.reduce_mean(ratio * advantage)

        kl_divergence = tf.reduce_sum(old_policy_prob * (tf.log(old_policy_prob + 1e-10) - tf.log(new_policy_prob + 1e-10)), axis=1)
        mean_kl_divergence = tf.reduce_mean(kl_divergence)

        grads = tf.gradients(surrogate_loss, self.actor.trainable_weights)
        grads_flatten = tf.concat([tf.reshape(g, [-1]) for g in grads], axis=0)
        fisher_vector_product = tf.gradients(mean_kl_divergence, self.actor.trainable_weights)
        fisher_vector_product_flatten = tf.concat([tf.reshape(fvp, [-1]) for fvp in fisher_vector_product], axis=0)
        fisher_vector_product_gradient = tf.reduce_sum(grads_flatten * fisher_vector_product_flatten)

        conjugate_gradient_step_direction = tf.placeholder(tf.float32, shape=(None,))
        conjugate_gradient_step = tf.gradients(fisher_vector_product_gradient, self.actor.trainable_weights)
        conjugate_gradient_step = tf.concat([tf.reshape(cgs, [-1]) for cgs in conjugate_gradient_step], axis=0)
        conjugate_gradient_step = conjugate_gradient_step / (conjugate_gradient_step @ conjugate_gradient_step_direction) * conjugate_gradient_step_direction

        flat_actor_gradients = tf.placeholder(tf.float32, shape=(None,))
        flat_fisher_vector_product = tf.placeholder(tf.float32, shape=(None,))
        kl_divergence_surrogate_loss_gradients = tf.gradients(mean_kl_divergence, self.actor.trainable_weights, -flat_actor_gradients)
        kl_divergence_surrogate_loss_gradients_flatten = tf.concat([tf.reshape(kldsg, [-1]) for kldsg in kl_divergence_surrogate_loss_gradients], axis=0)
        fisher_vector_product_surrogate_loss_gradients = tf.gradients(fisher_vector_product_gradient, self.actor.trainable_weights, flat_fisher_vector_product)
        fisher_vector_product_surrogate_loss_gradients_flatten = tf.concat([tf.reshape(fvpslg, [-1]) for fvpslg in fisher_vector_product_surrogate_loss_gradients], axis=0)
        grads_surrogate_loss_gradients = kl_divergence_surrogate_loss_gradients_flatten + fisher_vector_product_surrogate_loss_gradients_flatten

        conjugate_gradient_step_direction_result = np.zeros_like(flat_actor_gradients.shape)
        for _ in range(10):  # 通过共轭梯度法求解方程组
            feed_dict = {
                advantage: np.zeros((1, 1)),
                old_policy_prob: np.zeros((1, self.action_size)),
                flat_actor_gradients: np.zeros_like(conjugate_gradient_step_direction_result),
                flat_fisher_vector_product: conjugate_gradient_step_direction_result,
            }
            for i, placeholder in enumerate(self.actor._feed_input_tensors):
                feed_dict[placeholder] = np.zeros((1, *self.actor._feed_input_shapes[i][1:]))

            conjugate_gradient_step_direction_result = fisher_vector_product_gradients_result = grads_surrogate_loss_gradients_result = np.zeros_like(conjugate_gradient_step_direction_result)

            for _ in range(10):  # 通过逐步迭代求解共轭梯度方向
                feed_dict[conjugate_gradient_step_direction] = conjugate_gradient_step_direction_result
                feed_dict[flat_actor_gradients] = conjugate_gradient_step_direction_result

                cgsdr, fvpgdr, gslgdr = tf.keras.backend.get_session().run(
                    [conjugate_gradient_step_direction, fisher_vector_product_gradients, grads_surrogate_loss_gradients],
                    feed_dict=feed_dict
                )
                alpha = conjugate_gradient_step_direction_result @ conjugate_gradient_step / (cgsdr @ fisher_vector_product_gradients)
                conjugate_gradient_step_direction_result += alpha * cgsdr
                fisher_vector_product_gradients_result += alpha * fvpgdr
                grads_surrogate_loss_gradients_result += alpha * gslgdr

                residual = fisher_vector_product_gradients_result - grads_surrogate_loss_gradients_result
                beta = residual @ fisher_vector_product_gradients_result / (fisher_vector_product_gradients_result @ fisher_vector_product_gradients_result)
                conjugate_gradient_step_direction_result -= beta * residual

        return surrogate_loss

    def compute_advantages(self, rewards, values, dones):
        advantages = np.zeros_like(rewards, dtype=np.float32)
        running_add = 0
        for t in reversed(range(len(rewards))):
            running_add = running_add * self.gamma * (1 - dones[t]) + rewards[t]
            advantages[t] = running_add - values[t]
            running_add = values[t] + advantages[t] * self.gamma * self.lmbda
        return advantages

    def train(self, states, actions, rewards, values, dones):
        states = np.vstack(states)
        actions = np.vstack(actions)
        rewards = np.vstack(rewards)
        values = np.vstack(values)
        dones = np.vstack(dones)

        old_policy_prob = self.actor.predict(states)
        advantages = self.compute_advantages(rewards, values, dones)

        # 计算共轭梯度方向
        feed_dict = {
            self.actor.input: states,
            self.actor.output: old_policy_prob,
            self.actor.sample_weights[0]: advantages,
        }
        flat_actor_gradients_result, flat_fisher_vector_product_result = tf.keras.backend.get_session().run(
            [tf.concat([tf.reshape(grad, [-1]) for grad in tf.gradients(self.trpo_loss, self.actor.trainable_weights)], axis=0),
             tf.concat([tf.reshape(grad, [-1]) for grad in tf.gradients(tf.reduce_sum(tf.gradients(self.trpo_loss, self.actor.trainable_weights) @
                             tf.gradients(self.trpo_loss, self.actor.trainable_weights), axis=1), self.actor.trainable_weights)], axis=0)],
            feed_dict=feed_dict
        )

        # 计算步长
        conjugate_gradient_step_direction_result = np.zeros_like(flat_actor_gradients_result)
        for _ in range(10):  # 通过共轭梯度法求解方程组
            feed_dict = {
                self.actor.input: states,
                self.actor.output: old_policy_prob,
                self.actor.sample_weights[0]: advantages,
                tf.placeholder(tf.float32, shape=(None,)): conjugate_gradient_step_direction_result,
                tf.placeholder(tf.float32, shape=(None,)): flat_fisher_vector_product_result,
            }
            flat_actor_gradients_result, flat_fisher_vector_product_result = tf.keras.backend.get_session().run(
                [tf.concat([tf.reshape(grad, [-1]) for grad in tf.gradients(self.trpo_loss, self.actor.trainable_weights)], axis=0),
                 tf.concat([tf.reshape(grad, [-1]) for grad in tf.gradients(tf.reduce_sum(tf.gradients(self.trpo_loss, self.actor.trainable_weights) @
                                 tf.gradients(self.trpo_loss, self.actor.trainable_weights), axis=1), self.actor.trainable_weights)], axis=0)],
                feed_dict=feed_dict
            )
            alpha = conjugate_gradient_step_direction_result @ flat_actor_gradients_result / (conjugate_gradient_step_direction_result @ flat_fisher_vector_product_result)
            conjugate_gradient_step_direction_result += alpha * flat_actor_gradients_result

        # 利用共轭梯度方向更新参数
        feed_dict = {
            self.actor.input: states,
            self.actor.output: old_policy_prob,
            self.actor.sample_weights[0]: advantages,
            tf.placeholder(tf.float32, shape=(None,)): conjugate_gradient_step_direction_result,
        }
        new_actor_parameters = tf.keras.backend.get_session().run(
            [tf.concat([tf.reshape(param - alpha * grad, [-1]) for param, grad in zip(self.actor.trainable_weights, tf.gradients(self.trpo_loss, self.actor.trainable_weights))], axis=0)
             for alpha in [1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2]],
            feed_dict=feed_dict
        )
        new_actor_parameters = [np.reshape(new_param, param.shape) for new_param, param in zip(new_actor_parameters[0], self.actor.get_weights())]
        self.actor.set_weights(new_actor_parameters)

# 初始化环境和Agent
env = gym.make('CartPole-v1')
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
agent = TRPOAgent(state_size, action_size)

# 训练TRPO Agent
num_episodes = 500
for episode in range(num_episodes):
    state = env.reset()
    total_reward = 0
    states, actions, rewards, values, dones = [], [], [], [], []
    for time in range(500):  # 限制每个episode的步数，防止无限循环
        # env.render()  # 如果想可视化训练过程，可以取消注释此行
        action, action_prob = agent.get_action(state)
        next_state, reward, done, _ = env.step(action)
        total_reward += reward
        value = agent.actor.predict(np.reshape(state, [1, state_size]))[0]
        states.append(state)
        actions.append(action)
        rewards.append(reward)
        values.append(value)
        dones.append(done)
        state = next_state
        if done:
            print("Episode: {}, Total Reward: {}".format(episode + 1, total_reward))
            agent.train(states, actions, rewards, values, dones)
            break

# 关闭环境
env.close()

在这个例子中，我们定义了一个简单的TRPO Agent，包括演员（Actor）神经网络。在训练过程中，我们使用TRPO算法来更新演员网络的参数。请注意，TRPO算法的实现可能因问题的复杂性而有所不同，可能需要更多的技术和调整，如归一化奖励、使用更复杂的神经网络结构等。

草明
关注
  • 20
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TRPO(Trust Region Policy Optimization) 原理与代码实例讲解
程序员光剑
07-13 646
TRPO(Trust Region Policy Optimization) - 原理与代码实例讲解 1. 背景介绍 1.1 问题的由来 随着深度学习和强化学习（RL）的快速发展，
强化学习—— Trust Region Policy Optimization (TRPO算法)
Cyrus_May的博客
07-14 461
TRPO
【强化学习】Trust Region Policy Optization（TRPO）
sword_csdn的博客
11-22 952
目录Policy Gradient的问题 Policy Gradient的问题 由于数据的采样
JoyRL阅读笔记-2-Trust Region Policy Optimization
weixin_44533660的博客
11-05 503
深度强化学习TRPO算法
Trust Region Policy Optimization (TRPO)
guojunwu1977的博客
03-13 453
Trust Region Policy Optimization (TRPO) 是一种强化学习算法，专门设计来改善策略梯度方法在稳定性和效率方面的表现。由 John Schulman 等人在 2015 年提出，TRPO 的核心思想是在策略优化过程中引入一个信任区域（trust region），这个区域限制了新策略与旧策略之间的散度，从而确保了策略更新的安全性。
05 强化学习——Trust Region Policy Optimization(TRPO)论文解读
风雨潇潇一书生
12-06 626
论文地址：http://proceedings.mlr.press/v37/schulman15.pdf 推荐几篇关于论文解读博客： 英文： https://blog.csdn.net/xyp99/article/details/109378848 https://spinningup.openai.com/en/latest/algorithms/trpo.html 中文： https://blog.csdn.net/qq_28385535/article/details/104892071
（12-2）Trust Region Policy Optimization (TRPO)算法：TRPO算法的核心原理
最新发布
码农三叔
03-22 1107
总之，TRPO算法中的策略梯度计算是一个关键步骤，它通过计算策略参数的梯度，指导策略的更新，以最大化期望累积奖励。TRPO的核心思想是通过限制策略更新的幅度来保持策略的稳定性，这种限制是通过定义一个“信任区域”来实现的，该区域包含了在当前策略下执行的轨迹和在更新后策略下执行的轨迹之间的相对改进。TRPO的目标是最大化在这个信任区域内的期望累积奖励。TRPO通过构建一个目标函数和约束条件来实现策略优化，这些目标函数和约束条件是TRPO算法的核心，用于确定如何更新策略以最大化累积奖励，同时限制策略更新的幅度。
MODEL-ENSEMBLE TRUST-REGION POLICY OPTIMIZATION
KunBB的博客
09-19 1272
文献目录 文章目录1. INTRODUCTION 1. INTRODUCTION Model-based方法需要学习模型的非常严格的形式，并且需要仔细的调优才能使它们适用。尽管将基于模型的算法扩展到深度神经网络模型是一个简单的想法，但迄今为止，成功的应用相对较少。 基于模型的强化学习的标准方法在模型学习和政策优化之间交替。 在模型学习阶段，从与环境的相互作用中收集样本，并使用监督学习将动态模型拟...
【强化学习】15 —— TRPO（Trust Region Policy Optimization）
sinat_52032317的博客
11-03 1035
之前介绍的基于策略的方法包括策略梯度算法和 Actor-Critic 算法。这些方法虽然简单、直观，但在实际应用过程中会遇到训练不稳定的情况。回顾一下基于策略的方法：参数化智能体的策略，并设计衡量策略好坏的目标函数，通过梯度上升的方法来最大化这个目标函数，使得策略最优。这种算法有一个明显的缺点：当策略网络是深度模型时，沿着策略梯度更新参数，很有可能由于步长太长，策略突然显著变差，进而影响训练效果；同时由于采集到的数据的分布会随策略的更新而变化，步长太长，更新的策略可能变差，导致采集到的数据变差，进而陷入恶性
（12-1）Trust Region Policy Optimization (TRPO)算法：TRPO算法的介绍与背景
码农三叔
03-22 777
Trust Region Policy Optimization（TRPO）是一种用于深度强化学习的算法，旨在优化参数化策略以最大化累积奖励。TRPO 是由John Schulman等人于2015年提出的，是一种在连续动作空间中高效训练策略的算法。在本章的内容中，将详细讲解Trust Region Policy Optimization (TRPO)算法的知识，为读者步入后面知识的学习打下基础。
[深度强化学习] [2] Trust Region Policy Optimization & Proximal Policy Optimization
GrandpaDZB的博客
01-21 835
文章目录1 Vanilla Policy Gradient的缺陷与新的优化目标2 MM优化(Minorize-Maximization)与下界函数3 求解优化4 代码部分4.1 处理网络参数4.2 实用算法4.3 TRPO算法部分 1 Vanilla Policy Gradient的缺陷与新的优化目标 VPG优化策略的方法就是通过Policy Gradient进行梯度上升。梯度上升是对函数点的一阶近似，根据步长更新，一阶近似也就是超平面拟合局部，步长稍微大一点误差还是挺大的，容易优化出错。 强化学习对策略优
模型稳定性评估 简介
galoiszhou的博客
12-25 2500
解决OOT问题的一种常见方法是使用群体稳定性指数（Population Stability Index，PSI）等工具来监测模型在不同时间段或数据分布上的性能变化。OOT通常指的是模型在训练时使用的数据集与将来要在实际应用中使用的数据集有显著的时间差异，导致模型在未来的预测性能下降。通过 PSI 指标，可以得到不同样本（不同时间段给到模型的样本）下，模型在各分数段分布的稳定性。通常，期望分布可以是参考的基准分布，比如在时间点1的分布作为基准，而实际分布是在时间点2的分布。
监督学习 - 多层感知机回归（Multilayer Perceptron Regression，MLP Regression）
galoiszhou的博客
01-13 2427
（Multilayer Perceptron Regression，MLP Regression）是一种。（Artificial Neural Network，ANN）的形式，用于解决。多层感知机是一种包含多个层次的神经网络结构，其中包括。（最大迭代次数）等。这些参数可以根据实际问题进行调整。在实际应用中，可以使用深度学习框架（如。模型来实现多层感知机回归。）或者高层次的机器学习库（如。（隐藏层中的神经元数量）、
监督学习 - 随机森林回归（Random Forest Regression）
galoiszhou的博客
01-11 2249
随机森林是一种Bagging（Bootstrap Aggregating）方法，它通过对训练数据进行有放回的随机抽样（bootstrap抽样）构建多个决策树，并且在每个决策树的节点上使用随机特征子集来进行分裂。类被用来创建随机森林回归模型，并使用训练数据进行训练。最后，评估模型性能并通过图形显示实际数据点和模型预测结果。类来实现随机森林回归。
监督学习 - 梯度提升回归（Gradient Boosting Regression）
galoiszhou的博客
01-12 2048
用于解决回归问题。它通过迭代地训练一系列弱学习器（通常是决策树）来逐步提升模型的性能。梯度提升回归的基本思想是通过拟合前一轮模型的残差（实际值与预测值之差）来构建下一轮模型，从而逐步减小模型对训练数据的预测误差。（Gradient Boosting Regression）是一种。（树的最大深度）等。这些参数可以根据实际问题进行调整。在实际应用中，可以使用梯度提升回归的库，如。类，来实现梯度提升回归。
模型的召回率（Recall）
galoiszhou的博客
01-20 1888
在实际应用中，召回率对于那些对错过正例（漏报）比较敏感的场景非常重要，例如在医学领域中，对于一些疾病的诊断，遗漏病例可能导致严重的后果。然而，召回率的提高通常会伴随着假正例（False Positives）的增加，因此在一些场景中需要在召回率和准确率之间进行权衡。召回率（Recall），也称为灵敏度（Sensitivity）或真正例率（True Positive Rate），是用于评估二分类模型性能的指标之一。召回率衡量了模型正确识别正例的能力，即在所有实际正例中，模型成功识别的比例。
线性回归（Linear Regression）算法 简介
galoiszhou的博客
12-21 1749
线性回归（Linear Regression）算法根据已有的数据去寻找一条直线，让它尽可能地接近这些数据，再用这条直线预测新数据的可能结果，这个结果是一个具体的数值。Y = AX + B根据样本数据求出方程的最优解.
什么是Trust Region Policy Optimization
08-07
### 回答1： (TRPO)？ Trust Region Policy Optimization (TRPO) 是一种用于强化学习的算法，它通过限制策略更新的步长，以确保每次更新都不会使策略变得太差。TRPO 是一种基于梯度的方法，它通过最大化期望收益来优化策略。TRPO 的主要优点是它可以保证每次更新都会使策略变得更好，而不会使其变得更差。 ### 回答2： Trust Region Policy Optimization（TRPO）是一种用于优化强化学习策略的算法。TRPO通过在每次更新策略时限制更新量，来解决策略优化中的非线性优化问题。其目标是在保证策略改进的同时，尽量减小策略更新带来的影响。 TRPO的核心思想是在每次迭代中保持一个信任区域，该区域内的策略改进之后的表现要比当前策略好。通过限制策略更新的KL散度（Kullback-Leibler Divergence），TRPO保证了平稳的、逐步改进的过程。 TRPO的算法步骤如下：首先，通过采样数据来估计策略的梯度；其次，通过求解一个约束优化问题来计算策略更新的方向和大小；最后，采用线搜索来确定在保证改进的前提下，策略更新的步长。 TRPO相对于其他的策略优化算法有几个优点。首先，TRPO可以高效地利用采样数据，避免了需求大量样本的问题。其次，通过控制策略更新的幅度，TRPO可以保持算法的稳定性和鲁棒性。最后，TRPO可以应用于各种不同类型的强化学习任务，并取得不错的性能。 总之，Trust Region Policy Optimization 是一种通过限制策略更新的KL散度来优化强化学习策略的算法。其核心思想是在每次迭代中维持一个信任区域，通过约束优化问题来计算策略更新，并使用线搜索来确定更新步长。TRPO具有高效利用采样数据，保持稳定性和适应性强的优点，能够在不同任务中取得良好性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值