【强化学习】常用算法之一 “PPO”

最新推荐文章于 2024-06-06 21:34:27 发布

爱笑的男孩。

最新推荐文章于 2024-06-06 21:34:27 发布

阅读量1.3k

点赞数 2

分类专栏：强化学习 python 文章标签：算法 python 强化学习人工智能

本文链接：https://blog.csdn.net/code_and516/article/details/131450149

版权

python 同时被 2 个专栏收录

40 篇文章 5 订阅

订阅专栏

强化学习

8 篇文章 1 订阅

订阅专栏

作者主页：爱笑的男孩。的博客_CSDN博客-深度学习,活动,python领域博主爱笑的男孩。擅长深度学习,活动,python,等方面的知识,爱笑的男孩。关注算法,python,计算机视觉,图像处理,深度学习,pytorch,神经网络,opencv领域.https://blog.csdn.net/Code_and516?type=blog个人简介：打工人。

持续分享：机器学习、深度学习、python相关内容、日常BUG解决方法及Windows&Linux实践小技巧。

如发现文章有误，麻烦请指出，我会及时去纠正。有其他需要可以私信我或者发我邮箱:zhilong666@foxmail.com

强化学习（Reinforcement Learning）作为一种机器学习的分支，旨在让智能体通过与环境的交互来学习最优的行为策略。近年来，强化学习在各个领域取得了重要的突破，其中Proximal Policy Optimization（PPO）算法是一种重要的策略优化算法。

本文将详细讲解强化学习常用算法之一“PPO”

一、简介

强化学习是一种通过智能体与环境的互动来学习最优行为策略的机器学习方法。相较于监督学习和无监督学习，强化学习的特点在于具有延迟奖赏和试错机制。在强化学习中，智能体通过选择动作来影响环境，并且从环境中获得奖励作为反馈。强化学习的目标是通过与环境的交互，使得智能体能够学会最优的行为策略。

PPO算法属于策略优化（Policy Optimization）算法家族，是由OpenAI在2017年提出的。与其他策略优化算法相比，PPO算法具有较高的样本利用率和较好的收敛性能。该算法在分布式训练和大规模模型上都表现出了较好的性能，因此被广泛应用于各个领域，如机器人控制、自动驾驶、游戏等。

二、发展史

在介绍PPO算法之前，需要先了解一些相关的算法。PPO算法是基于TRPO（Trust Region Policy Optimization）算法的改进。TRPO算法最初由Schulman等人于2015年提出，通过引入约束条件来保证每次更新的策略改变不会太大，从而确保策略的稳定性。然而，TRPO算法的计算复杂度较高，限制了其应用范围。

为了解决TRPO算法的计算复杂度问题，Schulman等人在2017年提出了PPO算法。PPO算法通过引入一个修剪概率比率的约束，取代了TRPO算法中的相对熵约束。这样一来，PPO算法的计算复杂度大大降低，使得其在实际应用中更加高效。

三、算法公式讲解

1. 目标函数

PPO算法的目标是最大化预期回报函数。设状态为s，行动为a，策略函数为π(a|s)，价值函数为V(s)，回报函数为R。目标是最大化状态转换的总回报函数G。根据策略梯度定理，可以得到以下目标函数：

J(θ)=E[R(θ)] =E[∑t=0∞γt rt]

其中，θ表示策略参数，γ表示折扣因子。

2. Surrogate目标函数

由于直接优化目标函数需要进行复杂的概率计算，PPO采用了一种近似的优化目标函数。引入一个由策略生成的新旧策略比率，即π(θ)/π(θ_old)。于是目标函数可以转化为：

J_surrogate(θ)=E[min(ratio(θ)A(θ), clip(ratio(θ), 1-ε, 1+ε)A(θ))]

其中，A(θ)=Q(s,a)-V(s)表示优势函数，ratio(θ)=π(a|s)/π_old(a|s)表示比率，ε表示剪切范围。

3. 更新步骤

PPO算法通过交替地进行策略评估和策略改进来训练智能体。在每次迭代中，首先使用当前策略收集一批经验数据，然后使用这些数据来计算并更新策略。具体的更新步骤如下：

收集经验数据；
计算梯度并优化策略函数；
更新价值函数。

四、算法原理

PPO算法的核心原理是使用近端策略优化，即在每一次迭代中，通过利用大量采样数据来不断优化策略，同时限制策略的变化范围，避免过大的策略更新。

PPO算法主要包括两个步骤：采样和优化。在采样阶段，算法通过与环境的交互来收集训练数据。在优化阶段，算法利用收集到的数据来更新策略参数，并根据目标函数的梯度信息来更新网络参数。

PPO算法的基本思路是使用一个重要度采样比率来控制策略更新的范围。在每一次更新中，算法会计算新策略和旧策略之间的重要度采样比率，并利用该比率来限制策略更新的范围。通过引入一个剪切项来限制策略更迭过大，PPO算法可以有效地提高训练的稳定性和效率。

五、算法功能

PPO算法具有以下几个功能：

基于策略的优化：PPO算法通过优化策略来提高智能体在环境中的性能，从而实现优化决策和行为。
高效稳定：PPO算法通过限制策略更新的范围，避免过大的更新，从而提高训练的稳定性和效率。
广泛适用性：PPO算法适用于解决连续动作空间和高维状态空间问题，可以应用于多个领域，如机器人控制、游戏智能等。

六、示例代码

下面是一个简单的PPO算法示例代码，用于解决CartPole强化学习任务。

首先，安装必要的依赖库：

pip install tensorflow
pip install gym

接下来，编写PPO算法的代码：

# -*- coding: utf-8 -*-
import tensorflow as tf
import gym
import numpy as np

env = gym.make('CartPole-v1')
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n
hidden_dim = 32
lr = 0.001

actor_model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(state_dim,)),
    tf.keras.layers.Dense(hidden_dim, activation='relu'),
    tf.keras.layers.Dense(action_dim, activation='softmax')
])

critic_model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(hidden_dim, activation='relu', input_shape=(state_dim,)),
    tf.keras.layers.Dense(hidden_dim, activation='relu'),
    tf.keras.layers.Dense(1)
])

actor_optimizer = tf.keras.optimizers.Adam(learning_rate=lr)
critic_optimizer = tf.keras.optimizers.Adam(learning_rate=lr)

def choose_action(state):
    logits = actor_model.predict(state[np.newaxis, :])[0]
    action = np.random.choice(range(action_dim), p=logits)
    return action

def compute_return(rewards, gamma):
    returns = np.zeros_like(rewards)
    G = 0
    for t in reversed(range(len(rewards))):
        G = rewards[t] + gamma * G
        returns[t] = G
    return returns

def compute_advantage(states, rewards, values, gamma, lamda):
    returns = compute_return(rewards, gamma)
    values = np.append(values, 0)
    deltas = rewards + gamma * values[1:] - values[:-1]
    advantages = np.zeros_like(rewards)
    A = 0
    for t in reversed(range(len(rewards))):
        A = deltas[t] + gamma * lamda * A
        advantages[t] = A
    return returns, advantages

def train_actor(states, actions, advantages, old_probs, eps):
    with tf.GradientTape() as tape:
        logits_new = actor_model(states, training=True)
        probabilities_new = tf.reduce_sum(tf.one_hot(actions, action_dim) * logits_new, axis=1)
        ratios = tf.exp(tf.math.log(probabilities_new) - tf.math.log(old_probs))
        surrogate_obj1 = ratios * advantages
        surrogate_obj2 = tf.clip_by_value(ratios, 1-eps, 1+eps) * advantages
        surrogate_obj = tf.minimum(surrogate_obj1, surrogate_obj2)
        loss = -tf.reduce_mean(surrogate_obj)
    grads = tape.gradient(loss, actor_model.trainable_variables)
    actor_optimizer.apply_gradients(zip(grads, actor_model.trainable_variables))

def train_critic(states, returns):
    with tf.GradientTape() as tape:
        values = critic_model(states, training=True)
        mse = tf.keras.losses.MeanSquaredError()
        loss = mse(returns, tf.squeeze(values))
    grads = tape.gradient(loss, critic_model.trainable_variables)
    critic_optimizer.apply_gradients(zip(grads, critic_model.trainable_variables))

gamma = 0.99
lamda = 0.95
eps = 0.2
max_episodes = 200
max_steps_per_episode = 1000

for episode in range(max_episodes):
    state = env.reset()
    done = False
    episode_reward = 0
    states, actions, rewards, values, old_probs = [], [], [], [], []

    for step in range(max_steps_per_episode):
        action = choose_action(state)
        next_state, reward, done, _ = env.step(action)

        states.append(state)
        actions.append(action)
        rewards.append(reward)
        values.append(critic_model.predict(state[np.newaxis, :])[0])
        old_probs.append(actor_model.predict(state[np.newaxis, :])[0][action])

        episode_reward += reward
        state = next_state

        if done:
            break

    states = np.array(states)
    actions = np.array(actions)
    rewards = np.array(rewards)
    values = np.array(values)
    old_probs = np.array(old_probs)

    returns, advantages = compute_advantage(states, rewards, values, gamma, lamda)
    returns = returns.astype('float32')
    advantages = advantages.astype('float32')

    train_actor(states, actions, advantages, old_probs, eps)
    train_critic(states, returns)

    print(f"Episode {episode+1}: Reward = {episode_reward}")

env.close()

运行结果：

Episode 1: Reward = 14.0
Episode 2: Reward = 13.0
Episode 3: Reward = 9.0
...
Episode 198: Reward = 500.0
Episode 199: Reward = 500.0
Episode 200: Reward = 500.0

这个示例代码使用PPO算法来训练一个Actor模型和Critic模型，通过与环境交互收集训练数据并更新模型参数。最终，在CartPole任务中可以观察到奖励逐渐增加，达到最大奖励500的稳定水平。

七、总结

本文详细介绍了强化学习中的PPO算法，包括其简介、发展史、算法公式、算法原理、算法功能、示例代码和运行结果以及如何使用。PPO算法是一种基于策略的优化算法，通过最大化目标函数来优化策略，具有高效稳定和广泛适用性的特点。通过示例代码的讲解，读者可以了解PPO算法的具体实现和使用方法。希望本文对读者能够加深对PPO算法的理解，并能够运用到实际问题中。

爱笑的男孩。

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【强化学习】常用算法之一 “PPO”

强化学习是一种通过智能体与环境的互动来学习最优行为策略的机器学习方法。相较于监督学习和无监督学习，强化学习的特点在于具有延迟奖赏和试错机制。在强化学习中，智能体通过选择动作来影响环境，并且从环境中获得奖励作为反馈。强化学习的目标是通过与环境的交互，使得智能体能够学会最优的行为策略。PPO算法属于策略优化（Policy Optimization）算法家族，是由OpenAI在2017年提出的。与其他策略优化算法相比，PPO算法具有较高的样本利用率和较好的收敛性能。
复制链接

扫一扫