（12-4-3）TRPO算法优化实战：基于矩阵低秩分解的TRPO

最新推荐文章于 2024-07-21 13:38:21 发布

码农三叔

最新推荐文章于 2024-07-21 13:38:21 发布

阅读量1k

点赞数 18

分类专栏：强化学习从入门到实践文章标签：算法人工智能深度学习 python 强化学习

本文链接：https://blog.csdn.net/asd343442/article/details/137004090

版权

强化学习从入门到实践专栏收录该内容

77 篇文章 38 订阅

订阅专栏

12.4.7 评估TRPO在Acrobot 环境中的性能

编写文件main_acrobot.py，用于训练和评估基于 TRPO 算法的强化学习代理(agent)在 Acrobot 环境中的性能，并保存训练结果以备将来使用。具体实现代码如下所示。

import pickle

from src.environments import CustomAcrobotEnv
from src.models import PolicyNetwork, PolicyLR, ValueNetwork, ValueLR
from src.agents import TRPOGaussianNN
from src.algorithms import Trainer
from src.utils import Discretizer


if __name__ == "__main__":
    res_nn, res_lr = [], []
    env = CustomAcrobotEnv()
    for _ in range(100):
        # NN
        actor = PolicyNetwork(4, [16], 1).double()
        critic = ValueNetwork(4, [16], 1).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            gamma=0.9,
            delta=0.01,
            tau=0.9,
            cg_dampening=0.1,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        _, totals, _ = trainer.train(
            env,
            agent,
            epochs=20000,
            max_steps=1000,
            update_freq=10000,
            initial_offset=-1,
        )
        res_nn.append(totals)

        # LR
        discretizer = Discretizer(
            min_points=[-1, -1, -1, -1],
            max_points=[1, 1, 1, 1],
            buckets=[2, 2, 2, 2],
            dimensions=[[0, 1], [2, 3]]
        )

        actor = PolicyLR(4, 4, 2, 0.1).double()
        critic = ValueLR(4, 4, 2, 0.1).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            discretizer,
            discretizer,
            gamma=0.9,
            delta=0.01,
            tau=0.9,
            cg_dampening=0.1,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        _, totals, _ = trainer.train(
            env,
            agent,
            epochs=20000,
            max_steps=1000,
            update_freq=10000,
            initial_offset=-1,
        )
        res_lr.append(totals)

    with open('results/acro_nn.pkl','wb') as f:
        pickle.dump(res_nn, f)

    with open('results/acro_lr.pkl','wb') as f:
        pickle.dump(res_lr, f)

上述代码的实现流程如下所示：

（1）导入必要的模块和类，具体说明如下：

pickle：用于序列化和反序列化 Python 对象。
自定义的环境类 CustomAcrobotEnv，在 Acrobot 环境上的自定义变体。
自定义的神经网络模型类 PolicyNetwork、PolicyLR、ValueNetwork 和 ValueLR，用于构建代理的策略和值函数。
自定义的 TRPO 强化学习代理类 TRPOGaussianNN，包括策略更新和值函数更新的逻辑。
自定义的训练器类 Trainer，用于执行代理的训练和评估。

（2）创建两个空列表 res_nn 和 res_lr，用于存储训练结果。

（3）创建 Acrobot 环境：使用自定义的 CustomAcrobotEnv 创建 Acrobot 环境。

（4）循环训练代理：在循环中，首先创建一个使用神经网络的代理(agent)，具体说明如下：

创建 PolicyNetwork 和 ValueNetwork 实例，并设置网络结构。
创建 TRPOGaussianNN 代理对象，指定网络、算法参数等。
创建 Trainer 训练器对象。

然后调用 trainer.train 函数，对代理在环境中进行训练，具体说明如下：

epochs=20000：执行 20000 个训练周期。
max_steps=1000：每个周期最多执行 1000 步。
update_freq=10000：每 10000 步执行一次策略更新。
initial_offset=-1：初始偏移值。

最后将每个周期的总奖励添加到 res_nn 或 res_lr 中，具体取决于代理类型。

（5）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以供后续分析和可视化使用。

执行文件main_acrobot.py后会创建并训练两种不同类型的 TRPO 强化学习代理（res_nn 和 res_lr）在 Acrobot 环境中。然后将训练结果保存为两个不同的 pickle 文件（'results/acro_nn.pkl' 和 'results/acro_lr.pkl'），这些文件将包含训练期间每个周期的总奖励等信息。

12.4.8 评估TRPO在MountainCarContinuous-v0环境中的性能

编写文件main_mountaincar.py，用于训练和评估 TRPO 算法在 MountainCarContinuous-v0 环境中的性能，并保存训练结果以备将来使用。主要实现代码如下所示。

import pickle
import gym

from src.models import PolicyNetwork, PolicyLR, ValueNetwork, ValueLR
from src.agents import TRPOGaussianNN
from src.algorithms import Trainer
from src.utils import Discretizer


if __name__ == "__main__":
    res_nn, res_lr = [], []
    env = gym.make("MountainCarContinuous-v0")
    for _ in range(100):
        # NN
        actor = PolicyNetwork(2, [8], 1).double()
        critic = ValueNetwork(2, [8], 1).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            gamma=0.99,
            delta=0.01,
            tau=0.9,
            cg_dampening=0.05,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        agent, totals, timesteps = trainer.train(
            env,
            agent,
            epochs=300,
            max_steps=10000,
            update_freq=15000,
            initial_offset=10,
        )
        res_nn.append(totals)

        # LR
        discretizer = Discretizer(
            min_points=[-1.2, -0.07],
            max_points=[0.6, 0.07],
            buckets=[4, 4],
            dimensions=[[0], [1]]
        )

        actor = PolicyLR(4, 4, 1, 0.1).double()
        critic = ValueLR(4, 4, 1, 1.0).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            discretizer,
            discretizer,
            gamma=0.99,
            delta=0.01,
            tau=0.9,
            cg_dampening=0.05,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        _, totals, _ = trainer.train(
            env,
            agent,
            epochs=300,
            max_steps=10000,
            update_freq=15000,
            initial_offset=10,
        )
        res_lr.append(totals)

    with open('results/mount_nn.pkl','wb') as f:
        pickle.dump(res_nn, f)

    with open('results/mount_lr.pkl','wb') as f:
        pickle.dump(res_lr, f)

对上述代码的具体说明如下：

（1）创建两个空列表 res_nn 和 res_lr，用于存储训练结果。

（2）创建 MountainCarContinuous-v0 环境：使用 gym.make 创建 MountainCarContinuous-v0 环境。

（3）循环训练代理：在循环中，首先创建一个使用神经网络的代理(agent)，具体说明如下：

创建 PolicyNetwork 和 ValueNetwork 实例，并设置网络结构。
创建 TRPOGaussianNN 代理对象，指定网络、算法参数等。
创建 Trainer 训练器对象。

然后调用 trainer.train 函数，对代理在环境中进行训练，具体说明如下：

epochs=300：执行 300 个训练周期。
max_steps=10000：每个周期最多执行 10000 步。
update_freq=15000：每 15000 步执行一次策略更新。
initial_offset=10：初始偏移值。

最后，将每个周期的总奖励添加到 res_nn 或 res_lr 中，具体取决于代理类型。

（4）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以供后续分析和可视化使用。

12.4.9 评估TRPO在CustomPendulumEnv环境中的性能

编写文件main_pendulum.py，用于训练和评估 TRPO 算法在 CustomPendulumEnv 环境中的性能，并保存训练结果以供后续分析和可视化使用。具体实现代码如下所示。

import pickle

from src.environments import CustomPendulumEnv
from src.models import PolicyNetwork, PolicyLR, ValueNetwork, ValueLR
from src.agents import TRPOGaussianNN
from src.algorithms import Trainer
from src.utils import Discretizer

if __name__ == "__main__":
    res_nn, res_lr = [], []
    env = CustomPendulumEnv()
    for _ in range(100):
        # NN
        actor = PolicyNetwork(2, [16, 16], 1).double()
        critic = ValueNetwork(2, [16, 16], 1).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            gamma=0.99,
            delta=0.05,
            tau=0.9,
            cg_dampening=0.1,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        _, totals, _ = trainer.train(
            env,
            agent,
            epochs=2000,
            max_steps=1000,
            update_freq=15000,
            initial_offset=-1,
        )
        res_nn.append(totals)

        # LR
        discretizer = Discretizer(
            min_points=[-1, -5],
            max_points=[1, 5],
            buckets=[16, 16],
            dimensions=[[0], [1]]
        )

        actor = PolicyLR(16, 16, 4, 1.0).double()
        critic = ValueLR(16, 16, 4, 1.0).double()

        agent = TRPOGaussianNN(
            actor,
            critic,
            discretizer,
            discretizer,
            gamma=0.99,
            delta=0.05,
            tau=0.9,
            cg_dampening=0.1,
            cg_tolerance=1e-10,
            cg_iteration=10,
        )

        trainer = Trainer(actor_opt='sgd', critic_opt='sgd')
        _, totals, _ = trainer.train(
            env,
            agent,
            epochs=2000,
            max_steps=1000,
            update_freq=15000,
            initial_offset=-1,
        )
        res_lr.append(totals)

    with open('results/pend_nn.pkl','wb') as f:
        pickle.dump(res_nn, f)

    with open('results/pend_lr.pkl','wb') as f:
        pickle.dump(res_lr, f)

对上述代码的具体说明如下：

（1）创建两个空列表 res_nn 和 res_lr，用于存储训练结果。

（2）创建 CustomPendulumEnv 环境：使用 CustomPendulumEnv 创建自定义 Pendulum 环境。

（3）循环训练代理：在循环中，首先创建一个使用神经网络的代理(agent)，具体说明如下：

创建 PolicyNetwork 和 ValueNetwork 实例，并设置网络结构。
创建 TRPOGaussianNN 代理对象，指定网络、算法参数等。
创建 Trainer 训练器对象。

然后，调用 trainer.train 函数，对代理在环境中进行训练，具体说明如下：

epochs=2000：执行 2000 个训练周期。
max_steps=1000：每个周期最多执行 1000 步。
update_freq=15000：每 15000 步执行一次策略更新。
initial_offset=-1：初始偏移值。

最后，将每个周期的总奖励添加到 res_nn 或 res_lr 中，具体取决于代理类型。

（4）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以备将来使用。

未完待续

码农三叔

关注

18
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
（12-4-3）TRPO算法优化实战：基于矩阵低秩分解的TRPO

具体实现代码如下所示。（5）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以供后续分析和可视化使用。（4）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以供后续分析和可视化使用。（4）使用 pickle 模块将训练结果保存到文件中：分别将 res_nn 和 res_lr 保存到两个不同的 pickle 文件中，以备将来使用。
复制链接

扫一扫