【05.issa-lab】最新从零无死角系列-(04) isaac-lab之框架剖析：训练 train.py 流程，代码注释与仿真环境创建

江南才尽，年少无知！

已于 2025-02-20 23:36:02 修改

阅读量279

点赞数 3

分类专栏： # 05.isaac-lab-强化学习文章标签： isaac-lab 足式机器人强化学习 isaac-sim rsl_rl

于 2025-01-05 22:43:16 首次发布

本文链接：https://blog.csdn.net/weixin_43013761/article/details/144952004

版权

05.isaac-lab-强化学习专栏收录该内容

8 篇文章

订阅专栏

$\color{red}郑重声明：该系列博客为本人(WenhaiZhu)独家私有,禁止转载与抄袭,首次举报有谢,若有需请私信授权！$

${\color{blue}本系列博客链接为：}$ 【05.issac-lab】最新从零无死角系列-(00) 目录最新无死角源码讲解：https://blog.csdn.net/weixin_43013761/article/details/143084425

通过前面的博客完成了环境搭建，且对 isaac-lab 设计理念有了一定了解，下面就是对源码进行分析了，接下来该系列博客应该对 isaac-lab 源码进行讲解，本人不漏过任何细节，进行全面的分析，后续的工程与代码可能就没有这个待遇了。(*￣︶￣)

上一篇博客，了解 Isaac-sim 设计理念与基本结构。其中包含任务设计工作流程、强化学习库比较、Hydra 配置系统。目前 isaac-lab 支持的强化学习库有 SKRL、 rsl_rl、 rl_games、 Stable-Baselines3。后续过程中，首先以 rsl_rl 库为主，进行学习与讲解，因为本人方向主要为足式机器人，且对该库比较熟悉。不过也会进行拓展，对其他强化学习库也进行讲解与剖析。

重点：这里学到的，不仅仅是代码的理解，而是会告诉你应该如何取分析一套陌生，或者不熟悉的强化学习代码，通用思维与技巧，只要看明白这一系列博客，后面所有强化学习的代码或开源项目应该都是有能力独立阅读的。

思来想去，本人最终于还是决定从主体框架入手进行讲解，只有知道整体流程是如何的，在后续分析细节时才能不迷惘，所以顺着以下思路对代码进行剖析：
        √ 1：了解 Isaac-sim 设计理念与基本结构。
        2：掌握训练过程的总体流程(以任务为导向) --> 该篇博客。
        3：环境与强化学习库，或者强化学习算法是如何联系到一起的。
        4： ......待定

个人感觉，只要知道了这些东西，对于工程的整体把控应该算是不错了，后续就是细节的解刨了：比如如何创建带相机的机器人；如何构建各总各样的地形；如何获取网络的输出的力矩对机器人进行控制等。

注意：如果有提示大家，[大致过一遍即可，不用在意细节] 的地方，就不要钻牛角尖，快速阅读一下即可，后面会回过来百分百的进行详细分析。

$\color{purple} 本博客编写于：20250105，台式机为 ubuntu 20.04，3090 GeForce RTX 显存24G}$ ：与你现在的代码，或者环境等存在一定差异也在情理之中，故切勿认为该系列博客绝对正确，且百密必有一疏，若发现错误处，恳请各位读者直接指出，本人会尽快进行整改，尽量使得后面的读者少踩坑，评论部分我会进行记录与感谢，只有这样，该系列博客才能成为精品，这里先拜谢各位朋友了。

${\color{blue}{文末正下方中心}提供了本人 \color{red} 联系方式，\color{blue}点击本人照片即可显示WX→官方认证，请备注\color{red} 强化学习}。$

一、前言

上一篇博客中，主要对 isaac-lab 的设计理念进行了介绍，首先大致说明 Omniverse、Isaac-sim 、Isaac-lab 三者之间的关系。接着简单介绍了一下 isaac-lab 的设计理想，其主要是利用管理器这种方式，把每个模块设计成组件然后进行交互，这种不仅达到解耦的目的，且用户根据自己的需求，可以往管理器中添加自定义的模块，当然，这相对来说是比较高级的操作，不过没有关系，后面学习过程中会进行详细讲解。

该篇博客开始，将对源码进行分析与解读，若是读过本人之前简介 isaac-gym 相关博客，如【04.isaac-gym】最新从零无死角系列-(03) extreme-parkour之源码分析-tran.py一阶段训练过程整体框架讲解应该是具备一定开源代码阅读能力的，没有读过也没有关系，现在从零开始解读 isaac-lab 相关源码。关于 isaac-lab 源码是如何运行的，这里就不再讲解了，本人分析代码主要基于 .vscode/launch.json 如下：

        {
            "name": "Python: Train Environment",
            "type": "debugpy",
            "request": "launch",
            "args" : ["--task", "Isaac-Velocity-Rough-Unitree-Go2-v0", "env.scene.num_envs=128"], // "--headless"
            "program": "${workspaceFolder}/scripts/reinforcement_learning/rsl_rl/train.py",
            "console": "integratedTerminal",
            "justMyCode": false
        },
        {
            "name": "Python: Play Environment",
            "type": "debugpy",
            "request": "launch",
            "args" : ["--task", "Isaac-Velocity-Rough-Unitree-Go2-v0", "--num_envs", "32"],
            "program": "${workspaceFolder}/scripts/reinforcement_learning/rsl_rl/play.py",
            "console": "integratedTerminal"
        }

也就是说，以 Isaac-Velocity-Rough-Unitree-Go2-v0 这个任务为引导，进行源码的阅读与理解，其对应于终端训练的播放的指令为：

# 训练
python scripts/reinforcement_learning/rsl_rl/train.py --task=Isaac-Velocity-Rough-Unitree-Go2-v0 --headless

# 播放(查看训练效果)
python scripts/reinforcement_learning/rsl_rl/play.py --task=Isaac-Velocity-Rough-Unitree-Go2-v0 --num_envs 32

根据指令，可以知道 source/standalone/workflows/rsl_rl/train.py 就是主程序的如何，所以分析代码也应该以这里为切入口。

二.train.py 代码注释

$\color{blue}[大致过一遍即可，不用在意细节，后面有详细分析]:$ 为了熟悉训练过程大致流程，本人给出 scripts/reinforcement_learning/rsl_rl/train.py文件注释，如下所示：

# Copyright (c) 2022-2025, The Isaac Lab Project Developers.
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""Script to train RL agent with RSL-RL."""

"""Launch Isaac Sim Simulator first."""

import argparse
import sys

from omni.isaac.lab.app import AppLauncher # 对 Isaac Sim 应用程序进行分装的实用工具类

# local imports，用于管理 RSL-RL 的配置参数
import cli_args  # isort: skip, 跳过 isort 的排序


# add argparse arguments，用于解析命令行参数
parser = argparse.ArgumentParser(description="Train an RL agent with RSL-RL.")
# 训练期间是否录制视频
parser.add_argument("--video", action="store_true", default=False, help="Record videos during training.")
# 录制视频的长度
parser.add_argument("--video_length", type=int, default=200, help="Length of the recorded video (in steps).")
# 视频录制的时间间隔，以与环境交互的步数为单位
parser.add_argument("--video_interval", type=int, default=2000, help="Interval between video recordings (in steps).")
# 仿真引擎中模拟智能体的数量
parser.add_argument("--num_envs", type=int, default=None, help="Number of environments to simulate.")
# 任务名称
parser.add_argument("--task", type=str, default=None, help="Name of the task.")
# 环境种子
parser.add_argument("--seed", type=int, default=None, help="Seed used for the environment")
# 最大迭代次数
parser.add_argument("--max_iterations", type=int, default=None, help="RL Policy training iterations.")
# append RSL-RL cli arguments，添加 RSL-RL 的命令行参数
cli_args.add_rsl_rl_args(parser)
# append AppLauncher cli args，添加 AppLauncher 的命令行参数，其会覆盖配置文件中的参数
AppLauncher.add_app_launcher_args(parser)
# 进行参数解析，返回命令行基本参数与 hydra 格式配置参数
args_cli, hydra_args = parser.parse_known_args()

# always enable cameras to record video，如果需要录制视频，则启界面观测相机
if args_cli.video:
    args_cli.enable_cameras = True

# clear out sys.argv for hydra，清除命令行参数，只保留 hydra 格式参数
sys.argv = [sys.argv[0]] + hydra_args

# launch omniverse app，启动 Omniverse 应用程序，获取 isaac-sim app 应用 SimulationApp 对象
app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

"""Rest everything follows."""

import gymnasium as gym
import os
import torch
from datetime import datetime

from rsl_rl.runners import OnPolicyRunner

from omni.isaac.lab.envs import (
    DirectMARLEnv,
    DirectMARLEnvCfg,
    DirectRLEnvCfg,
    ManagerBasedRLEnvCfg,
    multi_agent_to_single_agent,
)
from omni.isaac.lab.utils.dict import print_dict
from omni.isaac.lab.utils.io import dump_pickle, dump_yaml

import omni.isaac.lab_tasks  # noqa: F401
from omni.isaac.lab_tasks.utils import get_checkpoint_path
from omni.isaac.lab_tasks.utils.hydra import hydra_task_config
from omni.isaac.lab_tasks.utils.wrappers.rsl_rl import RslRlOnPolicyRunnerCfg, RslRlVecEnvWrapper

torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.benchmark = False


@hydra_task_config(args_cli.task, "rsl_rl_cfg_entry_point")
def main(env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg, agent_cfg: RslRlOnPolicyRunnerCfg):
    """Train with RSL-RL agent."""

    # STEP: 1.更新 RSL-RL 的配置参数，使用非 hydra 命令行参数覆盖配置文件中的参数
    # override configurations with non-hydra CLI arguments，
    agent_cfg = cli_args.update_rsl_rl_cfg(agent_cfg, args_cli)
    # 更新环境配置，设置仿真引擎中模拟智能体的数量，命令行参数优先
    env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else env_cfg.scene.num_envs
    # 更新训练迭代次数，命令行参数优先，其会覆盖配置文件中的最大迭代次数
    agent_cfg.max_iterations = (
        args_cli.max_iterations if args_cli.max_iterations is not None else agent_cfg.max_iterations
    )

    # STEP: 2.设置环境种子，以及仿真运行设备，如 GPU 或者 CPU
    # set the environment seed
    # note: certain randomizations occur in the environment initialization so we set the seed here
    env_cfg.seed = agent_cfg.seed
    # 更新仿真硬件设备，命令行参数优先
    env_cfg.sim.device = args_cli.device if args_cli.device is not None else env_cfg.sim.device

    # STEP: 3.设置日志，以及训练模型，以及视屏记录的目录
    # specify directory for logging experiments
    log_root_path = os.path.join("logs", "rsl_rl", agent_cfg.experiment_name)
    log_root_path = os.path.abspath(log_root_path)
    print(f"[INFO] Logging experiment in directory: {log_root_path}")
    # specify directory for logging runs: {time-stamp}_{run_name}
    log_dir = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    if agent_cfg.run_name:
        log_dir += f"_{agent_cfg.run_name}"
    log_dir = os.path.join(log_root_path, log_dir)

    # STEP: 4.创建仿真环境，该为 isaac-sim 的仿真环境
    # create isaac environment
    env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None)

    # STEP: 5.如果任务为多类智能体任务，则将多类智能体任务转换为单类智能体任务，这是因为 RSL-RL 默认只支持单类智能体算法
    # 这里的多类并不是多个的意思，如把智能体分成两类，让他们进行格斗训练，或者左右手互相搏斗都属于多类智能体任务
    # convert to single-agent instance if required by the RL algorithm
    if isinstance(env.unwrapped, DirectMARLEnv):
        env = multi_agent_to_single_agent(env)

    # STEP: 6.保存恢复路径，如果需要恢复训练，则从恢复路径中加载模型
    # save resume path before creating a new log_dir
    if agent_cfg.resume:
        resume_path = get_checkpoint_path(log_root_path, agent_cfg.load_run, agent_cfg.load_checkpoint)

    # STEP: 6.视屏录制包装器，通过 gym.wrappers.RecordVideo 包装之后，训练过程中可根据参数自动录制视频
    # wrap for video recording
    if args_cli.video:
        video_kwargs = {
            "video_folder": os.path.join(log_dir, "videos", "train"), # 视频保存目录
            "step_trigger": lambda step: step % args_cli.video_interval == 0, # 每间隔 video_interval 步，该函数返回 True，则开始录制视频
            "video_length": args_cli.video_length, # 视频录制的长度
            "disable_logger": True, # 是否禁用日志记录
        }
        print("[INFO] Recording videos during training.")
        print_dict(video_kwargs, nesting=4)
        env = gym.wrappers.RecordVideo(env, **video_kwargs) # 将 env 包装为 gym.wrappers.RecordVideo 对象

    # STEP: 7.将环境包装为 RSL-RL 的向量(并行-多智能体)环境，简单的说就是对 env 输出结果进行处理，使其符合 OnPolicyRunner 的输入
    # wrap around environment for rsl-rl
    env = RslRlVecEnvWrapper(env)

    # STEP: 8.创建 OnPolicyRunner 对象，用于训练和评估，将当前 git 状态添加到日志中，如果需要恢复训练，则从恢复路径中加载模型
    # create runner from rsl-rl
    runner = OnPolicyRunner(env, agent_cfg.to_dict(), log_dir=log_dir, device=agent_cfg.device)
    # write git state to logs
    runner.add_git_repo_to_log(__file__)
    # load the checkpoint
    if agent_cfg.resume:
        print(f"[INFO]: Loading model checkpoint from: {resume_path}")
        # load previously trained model
        runner.load(resume_path)

    # STEP: 9.将环境配置和智能体配置保存到日志目录中, 用于训练参数的记录与后续回顾等
    # dump the configuration into log-directory
    dump_yaml(os.path.join(log_dir, "params", "env.yaml"), env_cfg)
    dump_yaml(os.path.join(log_dir, "params", "agent.yaml"), agent_cfg)
    dump_pickle(os.path.join(log_dir, "params", "env.pkl"), env_cfg)
    dump_pickle(os.path.join(log_dir, "params", "agent.pkl"), agent_cfg)

    # STEP: 10.运行训练，训练过程中会根据参数进行训练迭代，并记录训练过程中的数据
    # run training
    runner.learn(num_learning_iterations=agent_cfg.max_iterations, init_at_random_ep_len=True)

    # STEP: 11.训练迭代完成之后，关闭仿真环境
    # close the simulator
    env.close()


if __name__ == "__main__":
    # run the main function
    main()
    # close sim app
    simulation_app.close()

三、代码分析-环境创建

1.参数覆盖

在阅读完上面的注释之后，应该对于整体的训练过程稍微有点了解，其首先对命名行的参数进行了一些处理。命令行参数主要分为两个部分，一部分为普通命令行参数，另外一部分属于 Hydra 配置参数。后者在上一篇博客中有进行详细介绍，比如启动训练指令时，可附加参数 env.scene.num_envs=32。

关于普通命名行参数就不做过多解释了，不过从代码中可以看到 “–video”，“–video_length” 等参数。其是用来配置在训练过程中如何录制视屏的，该部分内容在下一篇博客中会进行详细讲解。

有的朋友可能存在一些疑问，那就是有的参数可以通过普通命令行指定，比如 --num_envs，且又可以通过 Hydra 配置，比如 env.scene.num_envs。他们若是同时配置，以谁为主呢？经过本人试验，–num_envs 参数会覆盖 env.scene.num_envs，且代码中也有体现：

@hydra_task_config(args_cli.task, "rsl_rl_cfg_entry_point")
def main(env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg, agent_cfg: RslRlOnPolicyRunnerCfg):
	......
    env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else env_cfg.scene.num_envs
    ......

首先 hydra 装饰器 @hydra_task_config 会处理好 env.scene.num_envs 参数，但是处理完成之后，若命令行配置了 --num_envs 参数，则会被其覆盖。关于参数 “–seed”、“–max_iterations” 也是同样会覆盖 hydra 配置。总的来说，普通命令行参数优先级是最高的。

2.启动 isaac-sim

加载智能体之前，当然是需要启动 isaac-sim，可以选择以无头或者渲染模式，主要通过 “–headless” 参数进行指定。代码中 AppLauncher 就是对 isaac-sim 应用程序进行分装的实用工具类，启动过程比较简单，核心代码如下所示：

# append AppLauncher cli args，添加 AppLauncher 的命令行参数，其会覆盖配置文件中的参数
AppLauncher.add_app_launcher_args(parser)

# launch omniverse app，启动 Omniverse 应用程序，获取 isaac-sim app 应用 SimulationApp 对象
app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

首先通过 AppLauncher.add_app_launcher_args(parser)，解析命令行关于 isaac-sim 相关的参数，具体代码位于 source/extensions/omni.isaac.lab/omni/isaac/lab/app/app_launcher.py 文件中的 add_app_launcher_args() 函数，其中还包含：

"--headless"：是一个布尔类型(bool)的参数  
	如果命令行参数 --headless 设置为 True，则强制使用无界面模式(训练过程，通常为该模式，可提高效率)
	如果命令行参数 --headless 设置为 False，则会查看环境变量 HEADLESS 的值来决定是否使用无界面模式

"--livestream"： 设置为 1 或 2 时，会自动启用 headless 模式(无图形界面模式),同时启用相应的实时流媒体功能。
   -1: 默认值，此时会使用环境变量 LIVESTREAM 的值来决定是否启用实时流媒体
	0(禁用实时流媒体）
	1(启用 Native 实时流媒体模式)，细节参考 https://docs.omniverse.nvidia.com/extensions/latest/ext_livestream/native.htm
	2(启用 WebRTC 实时流媒体模式)，细节参考 https://docs.omniverse.nvidia.com/extensions/latest/ext_livestream/webrtc.html

这个功能在以下场景很有用，在没有显示器的服务器上运行 Isaac Sim，需要远程查看模拟场景，在容器或云环境中运行仿真时。如果设置 --livestream 2，那么 Isaac Sim 
将会以 headless 模式运行，并启用 WebRTC 流媒体，你可以通过浏览器访问 http://localhost:8211/streaming/webrtc-client/ 来查看仿真画面。

"--enable_cameras"：enable_cameras 是一个布尔类型(bool)的参数，当设置为 True 时,会启用相机传感器并进行渲染，即使在无头模式(headless mode)下也会启用相机功能。

如果环境中包含任何相机传感器,必须将此标志设置为 True，否则相机传感器将无法正常工作。可以通过命令行参数 --enable_cameras 设置，
也可以通过环境变量 ENABLE_CAMERAS 设置，如果命令行参数为 False,则会使用环境变量 ENABLE_CAMERAS 的值作为实际设置。

"--device"：
	cpu: 使用 CPU 运行仿真
	cuda: 使用 GPU 运行仿真，默认使用设备 ID 为 0 的 GPU
	cuda:N: 使用指定 ID 号的 GPU 运行仿真，其中 N 是 GPU 的设备 ID 号。例如 "cuda:0" 表示使用 ID 为 0 的 GPU

剩下一些命令行参数比如：

"--verbose"    "--info"    "--experience"     "--kit_args"

这里就不再逐一介绍，因为在 def add_app_launcher_args() 函数中英文注释有详细说明。个人这几个参数暂时没有使用，若使用到，后续会单独分析。

3.创建环境

启动仿真程序之后，当然就是加载仿真环境，主要包含地形以及并行训练智能体等，深度相机等。直白的说，即使构建训练环境。其核心代码为：

    # STEP: 4.创建仿真环境，该为 isaac-sim 的仿真环境
    # create isaac environment
    env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None)

不过这里创建的 env 是 isaac-lab 最基本的环境，虽然其中已经包含了各个管理器，比如：Action Manager、Command Manager、Observation Manager 等等。且只要接收动作 action 即可完成与环境的交互，收集经验数据，且完成观测、回报、终结等计算过程。

不过正是因为其是 isaac-lab 中最基本的环境实例对象，功能比较单一，且输出的数据结构已经固定，比如说交互过程中，通过输入强化学习网络输出结果 actions 给到其 step() 函数：

obs_dict, rew, terminated, truncated, extras = self.env.step(actions)

其得到的结果分别为观测、回报、智能体是否终结、截断(达到设定生命周期最大值)。显然，该结果格式已经固定，但是要知道 isaac-lab 是支持多个强化学习库的，这些强化学习库并不是 isaac-lab 的一部分，输入接口是其他开发团队定义的。如何才能使得 isaac-lab 兼容 SKRL、RSL-RL、RL-Games 这么多强化学习库呢？

其实在上一篇博客中有提到，其使用了强化学习包装器：https://docs.robotsfan.com/isaaclab/source/overview/reinforcement-learning/rl_existing_scripts.html。关于强化学习库 RSL-RL 的包装其就是代码中的：

    env = RslRlVecEnvWrapper(env)

具体实现位于 source/extensions/omni.isaac.lab_tasks/omni/isaac/lab_tasks/utils/wrappers/rsl_rl/vecenv_wrapper.py 文件，这里就先跳过，除了强化学习包装器，还有如果两个包装器，都将在下一篇博客中进行详细介绍：

    # STEP: 5.如果任务为多类智能体任务，则将多类智能体任务转换为单类智能体任务，这是因为 RSL-RL 默认只支持单类智能体算法
    # 这里的多类并不是多个的意思，如把智能体分成两类，让他们进行格斗训练，或者左右手互相搏斗都属于多类智能体任务
    # convert to single-agent instance if required by the RL algorithm
    if isinstance(env.unwrapped, DirectMARLEnv):
        env = multi_agent_to_single_agent(env)

    # STEP: 6.视屏录制包装器，通过 gym.wrappers.RecordVideo 包装之后，训练过程中可根据参数自动录制视频
    # wrap for video recording
    if args_cli.video:
        video_kwargs = {
            "video_folder": os.path.join(log_dir, "videos", "train"), # 视频保存目录
            "step_trigger": lambda step: step % args_cli.video_interval == 0, # 每间隔 video_interval 步，该函数返回 True，则开始录制视频
            "video_length": args_cli.video_length, # 视频录制的长度
            "disable_logger": True, # 是否禁用日志记录
        }
        print("[INFO] Recording videos during training.")
        print_dict(video_kwargs, nesting=4)
        env = gym.wrappers.RecordVideo(env, **video_kwargs) # 将 env 包装为 gym.wrappers.RecordVideo 对象

四、代码分析-强化学习

通过上面你的代码分析，知道train.py 是通过 gym.make() 函数完成仿真训练环境构建的，不用多说，在这之后就是利用强化学习库，构建强化学习网络，利用从环境获取的经验轨迹数据进行训练：

    # STEP: 8.创建 OnPolicyRunner 对象，用于训练和评估，将当前 git 状态添加到日志中，如果需要恢复训练，则从恢复路径中加载模型
    # create runner from rsl-rl
    runner = OnPolicyRunner(env, agent_cfg.to_dict(), log_dir=log_dir, device=agent_cfg.device)

    # STEP: 10.运行训练，训练过程中会根据参数进行训练迭代，并记录训练过程中的数据
    # run training
    runner.learn(num_learning_iterations=agent_cfg.max_iterations, init_at_random_ep_len=True)

其实就是调用 https://github.com/leggedrobotics/rsl_rl 这强化学习库。本人还是比较熟悉的，如果使用过 https://github.com/leggedrobotics/legged_gym 训练过足式机器人，那么对该部分代码应该也是比较熟悉的。不过都没有关系，后续过程中本人会对其中的代码进行详细的分析。

五、结语

通过该篇博客的分析，以启动指令 source/standalone/workflows/rsl_rl/train.py 为线索，对 train.py 源码进行了分析。总体框架，从广意上来说还是比较简单的，无非就是三个操作：1.启动 isaac-sim 仿真引擎。2.创建仿真环境，进行一些包装。3.创建强化学习算法，与仿真环境进行交互，且进行训练，那么关于第2项也可以打√：

√ 2：掌握训练过程的总体流程(以任务为导向) --> 该篇博客。

甚至对于 [ 3.环境与强化学习库，或者强化学习算法是如何联系到一起的。] 也有了一定了解，不过并没有深入，因为这是下一篇博客的核心内容。