系列文章目录

---

前言

        Isaac Lab 是一个用于机器人学习的统一模块化框架，旨在简化机器人研究中的常见工作流程（如 RL、从演示中学习和运动规划）。它建立在英伟达 Isaac Sim 的基础上，利用最新的仿真功能实现逼真的场景和快速高效的仿真。该框架的核心目标是

• 模块化： 轻松定制和添加新环境、机器人和传感器。
• 灵活性： 适应社区不断变化的需求。
• 开放性： 保持开源，允许社区贡献和扩展框架。
• 包含电池： 包含大量可随时使用的环境、传感器和任务。

        Isaac Lab 的主要功能包括：由 PhysX 提供的快速准确的物理模拟、用于矢量化渲染的平铺渲染 API、用于提高鲁棒性和适应性的域随机化，以及对在云中运行的支持。

        有关该框架的更多信息，请参阅论文[MYY+23]。有关英伟达 Isaac 生态系统的说明，请查看常见问题部分。

许可证
        Isaac Lab 框架在 BSD-3 条款许可下开源。更多详情，请参阅许可证。

鸣谢
        Isaac Lab 的开发源于 Orbit 框架。如果您在学术出版物中引用该框架，我们将不胜感激：

---

一、开始入门

1.1 安装指南

注意事项

        我们已放弃对 Isaac Sim 2023.1.1 及以下版本的支持。我们建议使用最新的 Isaac Sim 4.1.0 版本，以受益于最新功能和改进。

        有关详细信息，请参阅 Isaac Sim 发行说明。

注意事项

        我们建议 Isaac Lab 的系统要求至少为 32GB RAM 和 16GB VRAM。有关 Isaac Sim 系统要求的完整列表，请参阅 Isaac Sim 系统要求。

        作为 Isaac Sim 4.0 版发布后的一项实验功能，Isaac Sim 还可以通过 pip 安装。这简化了安装过程，无需下载 Omniverse Launcher 并通过启动器安装 Isaac Sim。因此，有两种方法可以安装 Isaac Lab：

1.1.1 使用 Isaac Sim pip 进行安装

1.1.1.1 安装 Isaac Sim

        从 Isaac Sim 4.0 版开始，可以使用 pip 安装 Isaac Sim。这种方法是试验性的，可能与某些 Linux 发行版存在兼容性问题。如果遇到任何问题，请向 Isaac Sim 论坛报告。

注意事项

        使用 pip 安装 Isaac Sim 需要 GLIBC 2.34 以上版本的兼容性。要检查系统中的 GLIBC 版本，请使用 ldd --version 命令。

        这可能会对某些 Linux 发行版造成兼容性问题。例如，Ubuntu 20.04 LTS 默认使用 GLIBC 2.31。如果遇到兼容性问题，建议使用 Isaac Sim 二进制文件安装方法。

        要使用 pip 安装 Isaac Sim，我们建议首先创建一个虚拟环境。确保虚拟环境的 Python 版本为 Python 3.10。

conda create -n isaaclab python=3.10
conda activate isaaclab

# create a conda environment named isaaclab with python3.10
python3.10 -m venv isaaclab
# activate the conda environment
source isaaclab/bin/activate

        接下来，根据系统中可用的 CUDA 版本，安装支持 CUDA 的 PyTorch 2.2.2 版本。

pip install torch==2.2.2 --index-url https://download.pytorch.org/whl/cu118

pip install torch==2.2.2 --index-url https://download.pytorch.org/whl/cu121

        然后，安装运行 Isaac Lab 所需的 Isaac Sim 软件包：

pip install isaacsim-rl isaacsim-replicator isaacsim-extscache-physics isaacsim-extscache-kit-sdk isaacsim-extscache-kit isaacsim-app --extra-index-url https://pypi.nvidia.com

1.1.1.2 安装 Isaac Lab

1.1.1.2.1 克隆 Isaac Lab

注意事项

        我们建议创建 Isaac Lab 仓库的分叉，以便为项目做出贡献，但这并不是使用该框架的强制性要求。如果你创建了一个分叉，请在以下说明中用你的用户名替换 isaac-sim。

        将 Isaac Lab 仓库克隆到你的工作区：

git clone git@github.com:isaac-sim/IsaacLab.git

git clone https://github.com/isaac-sim/IsaacLab.git

注意事项

        我们提供了一个辅助可执行文件 isaaclab.sh，它提供了管理扩展的实用程序：

./isaaclab.sh --help

usage: isaaclab.sh [-h] [-i] [-f] [-p] [-s] [-t] [-o] [-v] [-d] [-c] -- Utility to manage Isaac Lab.

optional arguments:
   -h, --help           Display the help content.
   -i, --install [LIB]  Install the extensions inside Isaac Lab and learning frameworks (rl_games, rsl_rl, sb3, skrl) as extra dependencies. Default is 'all'.
   -f, --format         Run pre-commit to format the code and check lints.
   -p, --python         Run the python executable provided by Isaac Sim or virtual environment (if active).
   -s, --sim            Run the simulator executable (isaac-sim.sh) provided by Isaac Sim.
   -t, --test           Run all python unittest tests.
   -o, --docker         Run the docker container helper script (docker/container.sh).
   -v, --vscode         Generate the VSCode settings file from template.
   -d, --docs           Build the documentation from source using sphinx.
   -c, --conda [NAME]   Create the conda environment for Isaac Lab. Default name is 'isaaclab'.

 1.1.1.2.2 安装

        使用 apt 安装依赖项（在 Ubuntu 上）：

sudo apt install cmake build-essential

        运行 install 命令，遍历 source/extensions 目录中的所有扩展，并使用 pip（带 --editable 标志）安装它们：

./isaaclab.sh --install # or "./isaaclab.sh -i"

注释

        默认情况下，这将安装所有学习框架。如果只想安装特定框架，可以将框架名称作为参数传递。例如，要只安装 rl_games 框架，可以运行

./isaaclab.sh --install rl_games  # or "./isaaclab.sh -i rl_games"

        有效选项包括 rl_games、rsl_rl、sb3、skrl、robomimic 和 none。

1.1.2 使用 Isaac Sim 二进制文件进行安装

1.1.2.1 安装 Isaac Sim

1.1.2.1.1 下载预制二进制文件

        请按照 Isaac Sim 文档安装最新的 Isaac Sim 版本。

        要查看最低系统要求，请参阅此处的文档。

备注

        我们在 Ubuntu 20.04LTS 上使用 Isaac Sim 4.0 版和 NVIDIA 驱动程序 525.147 对 Isaac Lab 进行了测试。

        在 Linux 系统上，默认情况下，Isaac Sim 安装在 ${HOME}/.local/share/ov/pkg/isaac_sim-* 目录中，其中 * 与 Isaac Sim 版本相对应。

1.1.2.2 安装 Isaac Lab

1.1.2.2.1 克隆 Isaac Lab

注意事项

        我们建议创建 Isaac Lab 仓库的分叉，以便为项目做出贡献，但这并不是使用该框架的强制性要求。如果你创建了一个分叉，请在以下说明中用你的用户名替换 isaac-sim。

        将 Isaac Lab 仓库克隆到你的工作区：

git clone git@github.com:isaac-sim/IsaacLab.git

git clone https://github.com/isaac-sim/IsaacLab.git

注意事项

        我们提供了一个辅助可执行文件 isaaclab.sh，它提供了管理扩展的实用程序：

./isaaclab.sh --help

usage: isaaclab.sh [-h] [-i] [-f] [-p] [-s] [-t] [-o] [-v] [-d] [-c] -- Utility to manage Isaac Lab.

optional arguments:
   -h, --help           Display the help content.
   -i, --install [LIB]  Install the extensions inside Isaac Lab and learning frameworks (rl-games, rsl-rl, sb3, skrl) as extra dependencies. Default is 'all'.
   -f, --format         Run pre-commit to format the code and check lints.
   -p, --python         Run the python executable provided by Isaac Sim or virtual environment (if active).
   -s, --sim            Run the simulator executable (isaac-sim.sh) provided by Isaac Sim.
   -t, --test           Run all python unittest tests.
   -o, --docker         Run the docker container helper script (docker/container.sh).
   -v, --vscode         Generate the VSCode settings file from template.
   -d, --docs           Build the documentation from source using sphinx.
   -c, --conda [NAME]   Create the conda environment for Isaac Lab. Default name is 'isaaclab'.

1.1.2.2.2 创建 Isaac Sim 符号链接

        在已安装的 Isaac Sim 根文件夹和 Isaac Lab 目录中的 _isaac_sim 之间建立符号链接。这样就能方便地索引 python 模块并查找随 Isaac Sim 一起提供的扩展。

# enter the cloned repository
cd IsaacLab
# create a symbolic link
ln -s path_to_isaac_sim _isaac_sim
# For example: ln -s /home/nvidia/.local/share/ov/pkg/isaac-sim-4.1.0 _isaac_sim

1.1.2.2.3 设置 conda 环境（可选）

注意事项

        此步骤为可选步骤。如果使用的是与 Isaac Sim 绑定的 python，可以跳过这一步。

        可执行文件 isaaclab.sh 会使用 ./isaaclab.sh -p 命令自动获取与 Isaac Sim 绑定的 python（除非在虚拟环境中）。该可执行文件的行为类似于 python 可执行文件，可用于在模拟器上运行任何 python 脚本或模块。更多信息，请参阅文档。

        虽然可以选择使用虚拟环境，但我们推荐使用 conda。请按照此处的说明安装 conda。如果要使用 conda 创建虚拟环境，可以使用以下命令：

# Option 1: Default name for conda environment is 'isaaclab'
./isaaclab.sh --conda  # or "./isaaclab.sh -c"
# Option 2: Custom name for conda environment
./isaaclab.sh --conda my_env  # or "./isaaclab.sh -c my_env"

        如果使用 conda 创建虚拟环境，请确保在运行任何脚本之前激活环境。例如

conda activate isaaclab  # or "conda activate my_env"

        进入虚拟环境后，无需使用 ./isaaclab.sh -p / isaaclab.bat -p 运行 python 脚本。您可以通过运行 python 或 python3 来使用环境中默认的 python 可执行文件。不过，在本文档的其余部分，我们将假设您使用 ./isaaclab.sh -p / isaaclab.bat -p 运行 python 脚本。该命令等同于在虚拟环境中运行 python 或 python3。

1.1.2.2.4 安装

        使用 apt 安装依赖项（仅限 Linux）：

# these dependency are needed by robomimic which is not available on Windows
sudo apt install cmake build-essential

        运行 install 命令，遍历 source/extensions 目录中的所有扩展，并使用 pip（带 --editable 标志）安装它们：

./isaaclab.sh --install # or "./isaaclab.sh -i"

注释

        默认情况下，上述操作将安装所有学习框架。如果只想安装特定框架，可以将框架名称作为参数传递。例如，要只安装 rl_games 框架，可以运行

./isaaclab.sh --install rl_games  # or "./isaaclab.sh -i rl_games"

        有效选项包括 rl_games、rsl_rl、sb3、skrl、robomimic 和 none。

1.1.3 验证安装

1.1.3.1 验证 Isaac Sim 的安装

1.1.3.1.1 从 pip 安装 Isaac Sim

        确保虚拟环境已激活（如适用）

        检查模拟器是否按预期运行：

# note: you can pass the argument "--help" to see all arguments possible.
isaacsim

         默认情况下，这将启动一个空的迷你工具包窗口。

        要运行特定的体验文件，请运行

# experience files can be absolute path, or relative path searched in isaacsim/apps or omni/apps
isaacsim omni.isaac.sim.python.kit

注意事项

        首次运行 Isaac Sim 时，将从注册表中提取所有依赖的扩展名。这个过程可能需要 10 分钟以上，并且在首次运行每个体验文件时都需要执行。提取扩展名后，使用同一体验文件的连续运行将使用缓存的扩展名。

        此外，首次运行将提示用户接受《Nvidia Omniverse 许可协议》。要接受 EULA，请在出现以下提示时回复 “是”：

By installing or using Isaac Sim, I agree to the terms of NVIDIA OMNIVERSE LICENSE AGREEMENT (EULA)
in https://docs.omniverse.nvidia.com/isaacsim/latest/common/NVIDIA_Omniverse_License_Agreement.html

Do you accept the EULA? (Yes/No): Yes

        如果按照上述说明操作后模拟器无法运行或崩溃，则说明配置有误。要调试和排除故障，请查看 Isaac Sim 文档和论坛。

1.1.3.1.2 通过二进制文件安装 Isaac Sim

        为避免每次都要查找 Isaac Sim 安装目录，我们建议在剩余的安装说明中将以下环境变量导出到终端：

# Isaac Sim root directory
export ISAACSIM_PATH="${HOME}/.local/share/ov/pkg/isaac-sim-4.1.0"
# Isaac Sim python executable
export ISAACSIM_PYTHON_EXE="${ISAACSIM_PATH}/python.sh"

         有关常用路径的更多信息，请查阅 Isaac Sim 文档。

        检查模拟器是否按预期运行：

# note: you can pass the argument "--help" to see all arguments possible.
${ISAACSIM_PATH}/isaac-sim.sh

        检查模拟器是否通过独立的 python 脚本运行：

# checks that python path is set correctly
${ISAACSIM_PYTHON_EXE} -c "print('Isaac Sim configuration is now complete.')"
# checks that Isaac Sim can be launched from python
${ISAACSIM_PYTHON_EXE} ${ISAACSIM_PATH}/standalone_examples/api/omni.isaac.core/add_cubes.py

注意事项

        如果您使用的是以前版本的 Isaac Sim，则需要在安装后首次运行以下命令来删除所有旧的用户数据和缓存变量：

${ISAACSIM_PATH}/isaac-sim.sh --reset-user

        如果按照上述说明操作后模拟器无法运行或崩溃，则说明配置有误。要调试和排除故障，请查看 Isaac Sim 文档和论坛。

1.1.3.2 验证 Isaac Lab 安装

        要验证安装是否成功，请从软件源顶部运行以下命令：

# Option 1: Using the isaaclab.sh executable
# note: this works for both the bundled python and the virtual environment
./isaaclab.sh -p source/standalone/tutorials/00_sim/create_empty.py

# Option 2: Using python in your virtual environment
python source/standalone/tutorials/00_sim/create_empty.py

        上述命令将启动模拟器，并显示一个带有黑色地平面的窗口。您可以在终端上按 Ctrl+C 退出脚本。在 Windows 机器上，请使用 Ctrl+Break 或 Ctrl+fn+B 从命令提示符终止进程。

        如果看到此信息，则表示安装成功！🎉

1.1.4 在云中运行 Isaac Lab

        使用 Isaac Automator，Isaac Lab 可在各种云基础设施中运行。Isaac Automator 允许在公共云（目前支持 AWS、GCP、Azure 和阿里巴巴云）上快速部署 Isaac Sim 和 Isaac Lab。

        其结果是一个完全配置好的远程桌面云工作站，可在几分钟内根据预算用于 Isaac Lab 的开发和测试。Isaac Automator 支持各种 GPU 实例和停止启动功能，以节省云计算成本，还支持各种辅助工作流程的工具（如上传和下载数据、自动运行、部署管理等）。

1.1.4.1 安装 Isaac Automator

        有关最新、最完整的安装说明，请参阅 Isaac Automator。

        要使用 Isaac Automator，请先克隆软件仓库：

git clone https://github.com/isaac-sim/IsaacAutomator.git

        Isaac Automator 需要在系统中预装 docker。

• 要安装 Docker，请按照 Docker 网站上有关操作系统的说明进行操作。
• 按照安装后步骤页面上的 Docker 安装后步骤进行操作。这些步骤允许你在不使用 sudo 的情况下运行 Docker。

        Isaac Automator 还需要获取 NGC API 密钥。

• 通过加入英伟达™（NVIDIA®）开发者计划获取 Isaac Sim 容器的访问权限。
• 生成 NGC API 密钥，以便从英伟达™（NVIDIA®）GPU 云（NGC）访问锁定的容器映像。
  • 如果您还没有 NGC 帐户，这一步要求您创建一个 NGC 帐户。
  • 生成 API 密钥后，您需要从终端登录 NGC。

    docker login nvcr.io

  • 对于用户名，请完全按照所示输入 $oauthtoken。这是一个特殊的用户名，用于与 NGC 进行身份验证。

    Username: $oauthtoken
    Password: <Your NGC API Key>

1.1.4.2 运行 Isaac Automator

        要运行 Isaac Automator，首先要构建 Isaac Automator 容器： 

./build

        接下来，输入自动化程序容器：

./run

        接下来，为您首选的云运行已部署的脚本：

# AWS
./deploy-aws
# Azure
./deploy-azure
# GCP
./deploy-gcp
# Alibaba Cloud
./deploy-alicloud

        按照提示输入有关环境设置和凭据的信息。成功后，终端中将提供连接到云实例的说明。可以使用 SSH、noVCN 或 NoMachine 进行连接。

        有关每个云所需凭证和设置的详细信息，请访问 Isaac Automator 页面获取更多说明。

1.1.4.3 在云上运行 Isaac 实验室

        连接到云实例后，桌面上会出现一个显示 isaaclab.sh 的图标。启动 isaaclab.sh 可执行文件，它将打开一个新的终端。在终端中，Isaac Lab 命令的执行方式与本地运行相同。

        例如

./isaaclab.sh -p source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-v0

1.1.4.4 销毁开发

        为了节约成本，可以在不使用时销毁部署。这可以在 Automator 容器中完成，可以使用 ./run 命令进入。

        要销毁部署，请运行

./destroy <deployment-name>

1.2 开发人员指南

        在开发过程中，我们建议使用 Microsoft Visual Studio Code（VSCode）。英伟达™ Omniverse也建议使用VSCode，并有教程介绍如何使用VSCode调试Omniverse扩展。

1.2.1 设置 Visual Studio Code

        以下内容仅适用于通过 Omniverse Launcher 安装的 Isaac Sim。Isaac Lab资源库包含VSCode设置，可轻松设置开发环境。这些设置包含在 .vscode 目录中，其中包括以下文件：

.vscode
├── tools
│   ├── launch.template.json
│   ├── settings.template.json
│   └── setup_vscode.py
├── extensions.json
├── launch.json  # <- this is generated by setup_vscode.py
├── settings.json  # <- this is generated by setup_vscode.py
└── tasks.json

        请按照以下说明设置集成开发环境：

1. 在 Visual Studio Code IDE 上打开 Isaac Lab 目录
2. 按 Ctrl+Shift+P 键，选择任务，运行 VSCode 任务： 运行任务，然后在下拉菜单中运行 setup_python_env。

        如果一切执行正常，应该会创建以下文件：

• .vscode/launch.json： 包含调试 python 代码的启动配置。
• .vscode/settings.json： 包含 python 解释器和 python 环境的设置。

        有关 Omniverse VSCode 支持的更多信息，请参阅以下链接：

• Isaac Sim VSCode 支持
• 使用 VSCode 调试

1.2.2 配置 python 解释器

        在提供的配置中，我们将默认 python 解释器设置为使用 Omniverse 提供的 python 可执行文件。这在 .vscode/settings.json 文件中指定：

{
   "python.defaultInterpreterPath": "${workspaceFolder}/_isaac_sim/python.sh",
}

        如果你想使用不同的 python 解释器（例如，从你的 conda 环境中），你需要在 VSCode 的左下角选择并激活你所选择的 python 解释器，或者打开命令调板 (Ctrl+Shift+P) 并选择 Python 来更改所使用的 python 解释器： 选择解释器。

        有关如何为 VSCode 设置 Python 解释器的更多信息，请参阅 VSCode 文档。

1.2.3 资源库组织

        Isaac Lab 资源库结构如下：

IsaacLab
├── .vscode
├── .flake8
├── LICENSE
├── isaaclab.sh
├── pyproject.toml
├── README.md
├── docs
├── source
│   ├── extensions
│   │   ├── omni.isaac.lab
│   │   ├── omni.isaac.lab_assets
│   │   └── omni.isaac.lab_tasks
│   ├── standalone
│   │   ├── demos
│   │   ├── environments
│   │   ├── tools
│   │   ├── tutorials
│   │   └── workflows
└── VERSION

        源代码目录包含所有 Isaac Lab 扩展程序和独立应用程序的源代码。这两个目录是 Isaac Sim 支持的不同开发工作流程。下文将对此进行介绍。

1.2.3.1 扩展程序

        扩展程序是在 Isaac Sim 中开发应用程序的推荐方式。它们是构成 Omniverse 生态系统的模块化软件包。每个扩展程序都提供一组功能，可供其他扩展程序或独立应用程序使用。如果文件夹的配置目录中包含 extension.toml 文件，则该文件夹将被视为扩展。有关扩展的更多信息，请参阅 Omniverse 文档。

        Isaac Lab本身也为机器人学习提供扩展。这些扩展被写入 source/extensions 目录。每个扩展都以 python 包的形式编写，结构如下：

<extension-name>
├── config
│   └── extension.toml
├── docs
│   ├── CHANGELOG.md
│   └── README.md
├── <extension-name>
│   ├── __init__.py
│   ├── ....
│   └── scripts
├── setup.py
└── tests

        config/extension.toml 文件包含扩展的元数据。其中包括名称、版本、描述、依赖关系等。Omniverse 会使用这些信息加载扩展。docs 目录包含扩展的文档，其中有关于扩展的更多详细信息，以及一个 CHANGELOG 文件，该文件包含扩展在每个版本中所做的更改。

        < extension-name> 目录包含扩展的主 python 包。该目录还包含脚本目录，用于保存使用扩展管理器启用扩展后加载到 Omniverse 的基于 python 的应用程序。

        更具体地说，扩展启用后，config/extension.toml 文件中指定的 python 模块将被加载，包含 omni.ext.IExt 类子类的脚本将被执行。

import omni.ext

class MyExt(omni.ext.IExt):
   """My extension application."""

   def on_startup(self, ext_id):
      """Called when the extension is loaded."""
      pass

   def on_shutdown(self):
      """Called when the extension is unloaded.

      It releases all references to the extension and cleans up any resources.
      """
      pass

        在 Omniverse 中自动加载扩展，而在独立应用程序中使用 python 包则需要额外的步骤。为了简化构建过程，并避免理解 Omniverse 使用的 premake 构建系统，我们直接使用 setuptools python 软件包来构建扩展程序提供的 python 模块。这是通过扩展目录中的 setup.py 文件完成的。

注意

        仅使用扩展管理器加载到 Omniverse 的扩展不需要 setup.py 文件。

        最后，测试目录包含扩展的单元测试。这些测试使用 unittest 框架编写。值得注意的是，Omniverse 也提供了类似的测试框架。不过，它需要通过构建过程，而且不支持在独立应用程序中测试 python 模块。

1.2.3.2 扩展依赖关系管理

        某些扩展可能有依赖关系，需要安装其他软件包后才能使用。Python 依赖项由 setuptools 软件包处理，并在 setup.py 文件中指定，而 ROS 软件包或 apt 软件包等非 Python 依赖项则不在 setuptools 处理之列。为了处理这些依赖关系，我们创建了一个额外的安装程序，将在下一节介绍。

        在 isaac_lab_settings 部分下的 extension.toml 文件中，可以指定两种类型的依赖关系：

1. apt_deps： 需要安装的 apt 软件包列表。这些软件包使用 apt 软件包管理器安装。
2. ros_ws： 指向包含 ROS 软件包的 ROS 工作区的路径。这些软件包使用 rosdep 依赖关系管理器安装。

        例如，下面的 extension.toml 文件指定了扩展的依赖关系：

[isaac_lab_settings]
# apt dependencies
apt_deps = ["libboost-all-dev"]

# ROS workspace
# note: if this path is relative, it is relative to the extension directory's root
ros_ws = "/home/user/catkin_ws"

        这些依赖项是使用工具目录中提供的 install_deps.py 脚本安装的。要安装所有扩展的所有依赖项，请运行以下命令：

# execute from the root of the repository
# the script expects the type of dependencies to install and the path to the extensions directory
# available types are: 'apt', 'rosdep' and 'all'
python tools/install_deps.py all ${ISAACLAB_PATH}/source/extensions

注释

        目前，该脚本会在 Dockerfile.base 和 Dockerfile.ros2 的构建过程中自动执行。这可确保在构建扩展之前，已分别安装了所有 “apt ”和 “rosdep ”依赖项。

1.2.3.3 独立应用程序

        在典型的 Omniverse 工作流程中，首先启动模拟器，然后启用扩展，加载 python 模块并运行 python 应用程序。虽然这是一种推荐的工作流程，但并不总是能够使用这种工作流程。例如，在机器人学习中，必须完全控制模拟步进和所有其他功能，而不是异步等待模拟器步进。在这种情况下，有必要编写一个独立应用程序，使用 AppLauncher 启动模拟器，并通过 SimulationContext 类实现对模拟的完全控制。

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

from omni.isaac.lab.app import AppLauncher

# launch omniverse app
app_launcher = AppLauncher(headless=False)
simulation_app = app_launcher.app


"""Rest everything follows."""

from omni.isaac.lab.sim import SimulationContext

if __name__ == "__main__":
   # get simulation context
   simulation_context = SimulationContext()
   # reset and play simulation
   simulation_context.reset()
   # step simulation
   simulation_context.step()
   # stop simulation
   simulation_context.stop()

   # close the simulation
   simulation_app.close()

        source/standalone 目录包含使用 Isaac Lab 提供的扩展程序设计的各种独立应用程序。这些应用程序使用 python 编写，结构如下：

• demos： 包含各种演示应用程序，展示核心框架 omni.isaac.lab。
• environments： 包含使用不同代理运行 omni.isaac.lab_tasks 中定义的环境的应用程序。其中包括随机策略、零行动策略、远程操作或脚本状态机。
• 工具： 包含使用框架提供的工具的应用程序。其中包括转换资产、生成数据集等。
• 教程： 包含使用框架提供的 API 的分步教程。
• 工作流程： 包含使用各种学习型框架环境的应用程序。其中包括不同的强化学习或模仿学习库。

1.3 运行现有脚本

1.3.1 展示厅

        Isaac Lab 的主要核心界面扩展 omni.isaac.lab 提供了执行器、对象、机器人和传感器的主要模块。我们提供了一系列演示脚本和教程。它们展示了如何在代码中以最简便的方式使用所提供的接口。

        运行并检查几个快速演示脚本：

•  使用位置指令生成不同的四足动物并让机器人站立：

  ./isaaclab.sh -p source/standalone/demos/quadrupeds.py

• 生成不同的手臂，并应用随机关节位置指令：

  ./isaaclab.sh -p source/standalone/demos/arms.py

• 生成不同的手，并命令它们张开或合拢：

  ./isaaclab.sh -p source/standalone/demos/hands.py

• 生成具有不同配置的程序生成地形：

  ./isaaclab.sh -p source/standalone/demos/procedural_terrain.py

• 生成不同的可变形（软）体，让它们从高处坠落：

  ./isaaclab.sh -p source/standalone/demos/deformables.py

• 生成多个有助于可视化的标记：

  ./isaaclab.sh -p source/standalone/demos/markers.py

1.3.2 工作流程

        通过 Isaac Lab，我们还提供了一套基准环境，包含在 omni.isaac.lab_tasks 扩展中。我们使用 OpenAI Gym 注册表来注册这些环境。我们为每个环境提供了一个默认配置文件，其中定义了场景、观察、奖励和行动空间。

        运行 OpenAI Gym 可查看已注册的可用环境列表：

./isaaclab.sh -p source/standalone/environments/list_envs.py

1.3.2.1 基本智能体

        这些包括输出零或随机代理的基本智能体。它们有助于确保环境配置正确。

• 车杆上的 Zero-action agent:

  ./isaaclab.sh -p source/standalone/environments/zero_agent.py --task Isaac-Cartpole-v0 --num_envs 32

• 车杆示例的 Random-action agent：

  ./isaaclab.sh -p source/standalone/environments/random_agent.py --task Isaac-Cartpole-v0 --num_envs 32

1.3.2.2 状态机

        我们为环境提供了手工制作的状态机示例。这些示例有助于理解环境以及如何使用所提供的接口。这些状态机是用 warp 编写的，可以使用 CUDA 内核高效执行大量环境。

./isaaclab.sh -p source/standalone/environments/state_machine/lift_cube_sm.py --num_envs 32

 1.3.2.3 远程操作

        我们提供了在 SE(2) 和 SE(3) 空间内为机器人控制提供指令的接口。在 SE(2) 远程操作中，返回的命令是线性 x-y 速度和偏航率，而在 SE(3) 远程操作中，返回的命令是代表姿势变化的 6-D 向量。

        使用键盘设备进行逆运动学（IK）控制：

./isaaclab.sh -p source/standalone/environments/teleoperation/teleop_se3_agent.py --task Isaac-Lift-Cube-Franka-IK-Rel-v0 --num_envs 1 --teleop_device keyboard

        脚本会打印配置的远程操作事件。键盘事件如下

Keyboard Controller for SE(3): Se3Keyboard
    Reset all commands: L
    Toggle gripper (open/close): K
    Move arm along x-axis: W/S
    Move arm along y-axis: A/D
    Move arm along z-axis: Q/E
    Rotate arm along x-axis: Z/X
    Rotate arm along y-axis: T/G
    Rotate arm along z-axis: C/V

1.3.2.4 模仿学习

        使用远程操作设备还可以收集数据，以便从演示中学习（LfD）。为此，我们支持学习框架 Robomimic（仅限 Linux），并允许以 HDF5 格式保存数据。

1. 在 Isaac-Lift-Cube-Franka-IK-Rel-v0 环境中收集遥操作演示：

   # step a: collect data with keyboard
   ./isaaclab.sh -p source/standalone/workflows/robomimic/collect_demonstrations.py --task Isaac-Lift-Cube-Franka-IK-Rel-v0 --num_envs 1 --num_demos 10 --teleop_device keyboard
   # step b: inspect the collected dataset
   ./isaaclab.sh -p source/standalone/workflows/robomimic/tools/inspect_demonstrations.py logs/robomimic/Isaac-Lift-Cube-Franka-IK-Rel-v0/hdf_dataset.hdf5

2. 将数据集分为训练集和验证集：

   # install the dependencies
   sudo apt install cmake build-essential
   # install python module (for robomimic)
   ./isaaclab.sh -i robomimic
   # split data
   ./isaaclab.sh -p source/standalone//workflows/robomimic/tools/split_train_val.py logs/robomimic/Isaac-Lift-Cube-Franka-IK-Rel-v0/hdf_dataset.hdf5 --ratio 0.2

3. 使用 Robomimic 为 Isaac-Lift-Cube-Franka-IK-Rel-v0 训练 BC 代理：

   ./isaaclab.sh -p source/standalone/workflows/robomimic/train.py --task Isaac-Lift-Cube-Franka-IK-Rel-v0 --algo bc --dataset logs/robomimic/Isaac-Lift-Cube-Franka-IK-Rel-v0/hdf_dataset.hdf5

4. 播放学习到的模型，使结果可视化：

   ./isaaclab.sh -p source/standalone/workflows/robomimic/play.py --task Isaac-Lift-Cube-Franka-IK-Rel-v0 --checkpoint /PATH/TO/model.pth

1.3.2.5 强化学习

        我们为不同的强化库提供封装器。这些封装器将环境中的数据转换成相应库的函数参数和返回类型。

• 在 Isaac-Cartpole-v0 上使用 Stable-Baselines3 训练一个代理：

  # install python module (for stable-baselines3)
  ./isaaclab.sh -i sb3
  # run script for training
  # note: we set the device to cpu since SB3 doesn't optimize for GPU anyway
  ./isaaclab.sh -p source/standalone/workflows/sb3/train.py --task Isaac-Cartpole-v0 --headless --device cpu
  # run script for playing with 32 environments
  ./isaaclab.sh -p source/standalone/workflows/sb3/play.py --task Isaac-Cartpole-v0 --num_envs 32 --checkpoint /PATH/TO/model.zip
  # run script for recording video of a trained agent (requires installing `ffmpeg`)
  ./isaaclab.sh -p source/standalone/workflows/sb3/play.py --task Isaac-Cartpole-v0 --headless --video --video_length 200

• 在 Isaac-Reach-Franka-v0 上使用 SKRL 训练代理：

  # install python module (for skrl)
  ./isaaclab.sh -i skrl
  # run script for training
  ./isaaclab.sh -p source/standalone/workflows/skrl/train.py --task Isaac-Reach-Franka-v0 --headless
  # run script for playing with 32 environments
  ./isaaclab.sh -p source/standalone/workflows/skrl/play.py --task Isaac-Reach-Franka-v0 --num_envs 32 --checkpoint /PATH/TO/model.pt
  # run script for recording video of a trained agent (requires installing `ffmpeg`)
  ./isaaclab.sh -p source/standalone/workflows/skrl/play.py --task Isaac-Reach-Franka-v0 --headless --video --video_length 200

• 在 Isaac-Ant-v0 上使用 RL-Games 训练代理：

  # install python module (for rl-games)
  ./isaaclab.sh -i rl_games
  # run script for training
  ./isaaclab.sh -p source/standalone/workflows/rl_games/train.py --task Isaac-Ant-v0 --headless
  # run script for playing with 32 environments
  ./isaaclab.sh -p source/standalone/workflows/rl_games/play.py --task Isaac-Ant-v0 --num_envs 32 --checkpoint /PATH/TO/model.pth
  # run script for recording video of a trained agent (requires installing `ffmpeg`)
  ./isaaclab.sh -p source/standalone/workflows/rl_games/play.py --task Isaac-Ant-v0 --headless --video --video_length 200

• 在 Isaac-Reach-Franka-v0 上用 RSL-RL 训练代理：

  # install python module (for rsl-rl)
  ./isaaclab.sh -i rsl_rl
  # run script for training
  ./isaaclab.sh -p source/standalone/workflows/rsl_rl/train.py --task Isaac-Reach-Franka-v0 --headless
  # run script for playing with 32 environments
  ./isaaclab.sh -p source/standalone/workflows/rsl_rl/play.py --task Isaac-Reach-Franka-v0 --num_envs 32 --load_run run_folder_name --checkpoint model.pt
  # run script for recording video of a trained agent (requires installing `ffmpeg`)
  ./isaaclab.sh -p source/standalone/workflows/rsl_rl/play.py --task Isaac-Reach-Franka-v0 --headless --video --video_length 200

        上述所有脚本都会将训练进度记录到 Tensorboard 的日志目录中，该目录位于存储库的根目录下。日志目录的格式为 logs/<library>/<task>/<date-time>，其中 <library> 是学习框架的名称，<task> 是任务名称，<date-time> 是执行训练脚本的时间戳。

        要查看日志，请运行

# execute from the root directory of the repository
./isaaclab.sh -p -m tensorboard.main --logdir=logs

1.4 创建自己的项目

        传统上，利用 Isaac Lab 的功能构建新项目需要在 Isaac Lab 资源库中创建自己的扩展。然而，这种方法会使项目的可见性模糊不清，并使 Isaac Lab 从一个版本到另一个版本的更新复杂化。为了规避这些挑战，我们现在提供了一个预配置和可定制的扩展模板，用于在隔离环境中创建项目。

        该模板有三种不同的使用情况：

• 项目模板： 提供 Isaac Sim 和 Isaac Lab 功能的基本访问权限，非常适合需要独立环境的项目。
• Python 软件包： 便于与 Isaac Sim 的本地或虚拟 Python 环境集成，允许创建可在多个项目中共享和重复使用的 Python 包。
• Omniverse 扩展： 支持直接集成到 Omniverse 扩展工作流程中。

注意事项

        我们建议新项目使用扩展模板，因为它能提供更精简、更高效的工作流程。此外，它还能确保您的项目与 Isaac Lab 的最新功能和改进保持同步。

        要开始使用，请按照扩展模板库中的说明进行操作。

1.5 常见问题

1.5.1 Isaac Lab 在 Isaac 生态系统中处于什么位置？

        多年来，NVIDIA®（英伟达™）开发了大量用于机器人和人工智能的工具。这些工具利用 GPU 的强大功能加快了仿真的速度和逼真度。它们在仿真技术领域展现出了巨大的前景，目前已被全球许多研究人员和公司所采用。

        Isaac Gym [MWG+21] 为机器人学习提供了基于 GPU 的高性能物理仿真。它建立在 PhysX 基础之上，PhysX 支持刚体的 GPU 加速仿真和直接访问物理仿真数据的 Python API。与基于 CPU 的物理引擎相比，通过端到端的 GPU 管道，它可以实现较高的帧速率。该工具已成功应用于多个研究项目，包括腿部运动 [RHRH22] [RHBH22]、手部操纵 [HAM+22] [AML+22] 和工业装配 [NSA+22]。

        尽管 Isaac Gym 取得了巨大成功，但它并不是为机器人设计的通用模拟器。例如，它不包括可变形物体和刚性物体之间的交互、高保真渲染以及对 ROS 的支持。该工具主要被设计为预览版，以展示底层物理引擎的功能。随着 Isaac Sim 的发布，英伟达正在为机器人技术打造一款通用模拟器，并将 Isaac Gym 的功能集成到 Isaac Sim 中。

        Isaac Sim 是建立在 Omniverse 基础上的机器人仿真工具包，Omniverse 是一个通用平台，旨在将复杂的 3D 工作流程整合在一起。Isaac Sim 利用图形和物理仿真方面的最新进展，为机器人技术提供高保真仿真环境。它支持 ROS/ROS2、各种传感器仿真、域随机化工具和合成数据创建。Isaac Sim 支持平铺渲染，可跨环境进行矢量渲染，还支持使用 Isaac Automator 在云中运行。总之，它是机器人专家的强大工具，是机器人仿真领域的一大进步。

        在发布上述两款工具的同时，英伟达还发布了一套名为 IsaacGymEnvs 和 OmniIsaacGymEnvs 的开源环境，它们分别建立在 Isaac Gym 和 Isaac Sim 的基础之上。这些环境旨在展示底层模拟器的能力，并为了解模拟器在机器人学习方面的可能性提供一个起点。这些环境可用于基准测试，但不用于开发和测试自定义环境和算法。这正是 Isaac Lab 的用武之地。

        Isaac Lab 建立在 Isaac Sim 的基础上，利用最新的仿真技术为机器人学习提供了一个统一而灵活的框架。它的设计具有模块化和可扩展性，旨在简化机器人研究中的常见工作流程（如 RL、从演示中学习和运动规划）。虽然它包括一些预建环境、传感器和任务，但其主要目标是为开发和测试自定义环境和机器人学习算法提供一个开源、统一和易用的界面。它不仅继承了 Isaac Sim 的功能，还增加了许多与机器人学习研究相关的新功能。例如，在模拟中加入执行器动力学、程序化地形生成，以及支持从人类演示中收集数据。

        Isaac Lab 取代了之前的 IsaacGymEnvs、OmniIsaacGymEnvs 和 Orbit 框架，并将成为 Isaac Sim 的单一机器人学习框架。以前发布的框架已被弃用，我们鼓励用户按照我们的迁移指南过渡到 Isaac Lab。

1.5.2 为什么要使用 Isaac Lab？

        由于 Isaac Sim 仍然是闭源的，用户很难为模拟器做出贡献，也很难建立一个用于研究的通用框架。按照目前的发展方向，我们认为使用该模拟器的社区只会开发自己的框架，这将导致工作分散，重复劳动严重。这种情况在过去的其他模拟器中也曾出现过，我们认为这并不是社区前进的最佳方式。

        Isaac 实验室为社区提供了一个开源平台，让大家共同致力于设计基准和机器人学习系统，推动社区进步。这样，我们就能重复使用现有的组件和算法，并在彼此的工作基础上继续前进。这样做不仅省时省力，还能让我们专注于更重要的研究。我们希望 Isaac Lab 成为机器人学习研究的事实平台，并成为利用 Isaac Sim 的环境动物园。随着该框架的成熟，我们预计它将极大地受益于最新的仿真开发（作为英伟达公司和合作伙伴内部开发的一部分）和机器人研究。

        我们已经在与大学和研究机构的实验室合作，将他们的工作整合到 Isaac Lab 中，希望社区中的其他人也能加入我们的行列。如果您有兴趣为 Isaac Lab 做出贡献，请联系我们。

二、功能特点

2.1 任务设计工作流程

        环境定义了 agent 与仿真之间的接口。在最简单的情况下，环境为 agent 提供当前观察结果，并执行 agent 提供的操作。在马尔可夫决策过程（Markov Decision Process，MDP）的表述中，环境还可以提供额外信息，如当前奖励、已完成标志以及当前事件的相关信息。

        虽然环境界面简单易懂，但其实现方式会因任务的复杂程度而有很大不同。在强化学习（RL）中，环境的实现可分为几个部分，如奖励函数、观察函数、终止函数和重置函数。根据任务的复杂程度和所需的模块化水平，可以用不同的方式实现这些组件中的每一个。

        我们为使用该框架设计环境提供了两种不同的工作流程：

• 基于管理器： 环境被分解为处理环境不同方面（如计算观察结果、应用操作和应用随机化）的单个组件（或管理器）。用户为每个组件定义配置类，环境负责协调管理器并调用其功能。
• 直接：用户定义一个类，直接实现整个环境，无需单独的管理器。该类负责计算观察结果、应用操作和计算奖励。

        这两种工作流程各有利弊。基于管理器的工作流程更加模块化，可以轻松更换环境的不同组件。这在制作环境原型和试验不同配置时非常有用。另一方面，直接工作流程效率更高，可对环境逻辑进行更精细的控制。这在优化环境性能或实施难以分解为单独组件的复杂逻辑时非常有用。

2.1.1 基于管理器的环境

        大多数环境实现都遵循类似的结构。环境会处理输入的操作、仿真步骤、计算观察结果和奖励信号、应用随机化并重置终止的环境。受此启发，可以将环境分解为处理上述各项任务的单独组件。例如，观察管理器负责计算观察结果，奖励管理器负责计算奖励，终止管理器负责计算终止信号。这种方法在框架中被称为基于管理器的环境设计。

        基于管理器的环境通过将任务分解为由不同类管理的单个组件来促进任务的模块化实现。任务的每个组件，如奖励、观察、终止等，都可以指定为单独的配置类，然后传递给相应的管理器类。然后，管理器负责解析配置并处理其配置中指定的内容。

        不同管理器之间的协调由 envs.ManagerBasedRLEnv 类负责。它接收一个任务配置类实例（envs.ManagerBasedRLEnvCfg），该实例包含任务中每个组件的配置。在配置的基础上，设置场景并初始化任务。之后，在通过环境时，所有管理器都会被依次调用，以执行必要的操作。

        对于用户自己的任务，我们希望用户主要定义任务配置类，并使用现有的 envs.ManagerBasedRLEnv 类来实现任务。任务配置类应继承自基类 envs.ManagerBasedRLEnvCfg，并包含分配给每个组件的各种配置类（如 ObservationCfg 和 RewardCfg）的变量。

        以下类是 Cartpole 环境配置类的一部分。RewardsCfg 类定义了组成奖励函数的各个项。每个奖励项都由其函数实现、权重和传递给函数的附加参数定义。用户可以定义多个奖励项及其权重，以便在奖励函数中使用。

@configclass
class RewardsCfg:
    """Reward terms for the MDP."""

    # (1) Constant running reward
    alive = RewTerm(func=mdp.is_alive, weight=1.0)
    # (2) Failure penalty
    terminating = RewTerm(func=mdp.is_terminated, weight=-2.0)
    # (3) Primary task: keep pole upright
    pole_pos = RewTerm(
        func=mdp.joint_pos_target_l2,
        weight=-1.0,
        params={"asset_cfg": SceneEntityCfg("robot", joint_names=["cart_to_pole"]), "target": 0.0},
    )
    # (4) Shaping tasks: lower cart velocity
    cart_vel = RewTerm(
        func=mdp.joint_vel_l1,
        weight=-0.01,
        params={"asset_cfg": SceneEntityCfg("robot", joint_names=["slider_to_cart"])},
    )
    # (5) Shaping tasks: lower pole angular velocity
    pole_vel = RewTerm(
        func=mdp.joint_vel_l1,
        weight=-0.005,
        params={"asset_cfg": SceneEntityCfg("robot", joint_names=["cart_to_pole"])},
    )

        通过这种方法，我们可以通过切换某些组件来轻松改变任务的实现，同时保持代码的其余部分不变。在制作环境原型和试验不同配置时，这种灵活性是非常可取的。此外，这种灵活性还便于与他人合作实现环境，因为贡献者可以根据自己的任务规范选择使用不同的配置组合。

另请参见

        我们在《创建基于管理器的 RL 环境》一文中提供了使用基于管理器的工作流程建立环境的更详细教程。

2.1.2 直接式环境

        直接式环境更接近于传统环境的实现方式，即由一个脚本直接实现奖励函数、观察函数、重置以及环境的所有其他组件。这种方法不需要管理器类。相反，用户可以完全自由地通过基类 envs.DirectRLEnv 的应用程序接口来实现他们的任务。对于从 IsaacGymEnvs 和 OmniIsaacGymEnvs 框架迁移过来的用户来说，这种工作流程可能更为熟悉。

        在使用直接式实现定义环境时，我们希望用户定义一个实现整个环境的单一类。该任务类应继承自基本的 envs.DirectRLEnv 类，并拥有继承自 envs.DirectRLEnvCfg 的相应配置类。任务类负责设置场景、处理动作、计算奖励、观察结果、重置和终止信号。

        下面的函数是 Cartpole 环境类的一部分，负责计算奖励。

def _get_rewards(self) -> torch.Tensor:
    total_reward = compute_rewards(
        self.cfg.rew_scale_alive,
        self.cfg.rew_scale_terminated,
        self.cfg.rew_scale_pole_pos,
        self.cfg.rew_scale_cart_vel,
        self.cfg.rew_scale_pole_vel,
        self.joint_pos[:, self._pole_dof_idx[0]],
        self.joint_vel[:, self._pole_dof_idx[0]],
        self.joint_pos[:, self._cart_dof_idx[0]],
        self.joint_vel[:, self._cart_dof_idx[0]],
        self.reset_terminated,
    )
    return total_reward

        它调用的 compute_rewards() 函数是 Torch JIT 编译的，具有性能优势。

@torch.jit.script
def compute_rewards(
    rew_scale_alive: float,
    rew_scale_terminated: float,
    rew_scale_pole_pos: float,
    rew_scale_cart_vel: float,
    rew_scale_pole_vel: float,
    pole_pos: torch.Tensor,
    pole_vel: torch.Tensor,
    cart_pos: torch.Tensor,
    cart_vel: torch.Tensor,
    reset_terminated: torch.Tensor,
):
    rew_alive = rew_scale_alive * (1.0 - reset_terminated.float())
    rew_termination = rew_scale_terminated * reset_terminated.float()
    rew_pole_pos = rew_scale_pole_pos * torch.sum(torch.square(pole_pos).unsqueeze(dim=1), dim=-1)
    rew_cart_vel = rew_scale_cart_vel * torch.sum(torch.abs(cart_vel).unsqueeze(dim=1), dim=-1)
    rew_pole_vel = rew_scale_pole_vel * torch.sum(torch.abs(pole_vel).unsqueeze(dim=1), dim=-1)
    total_reward = rew_alive + rew_termination + rew_pole_pos + rew_cart_vel + rew_pole_vel
    return total_reward

        这种方法使环境的实现更加透明，因为逻辑是在任务类中定义的，而不是使用管理器抽象出来的。这对于实现难以分解成单独组件的复杂逻辑可能会有好处。此外，直接式实现可能会为环境带来更多性能优势，因为它允许使用 PyTorch JIT 或 Warp 等优化框架实现大块逻辑。这在需要优化环境中单个操作的大规模培训中可能很有价值。

另请参见

        我们在创建直接工作流 RL 环境中提供了使用直接工作流设置 RL 环境的更详细教程。

 2.2 多 GPU 和多节点训练

        Isaac Lab 支持多 GPU 和多节点强化学习。目前，该功能仅适用于 RL-Games 和 skrl 库工作流程。我们正在努力将此功能扩展到其他工作流程。

注意事项

        多 GPU 和多节点训练仅支持 Linux。目前不支持 Windows。这是因为 Windows 上的 NCCL 库存在限制。

2.2.1 多 GPU 训练

        对于复杂的强化学习环境，可能需要在多个 GPU 上扩大训练规模。通过使用 PyTorch 分布式框架，Isaac Lab 可以实现这一点。

        torch.distributed() API 用于启动多个训练进程，进程数量必须等于或小于可用 GPU 的数量。每个进程在专用 GPU 上运行，并启动自己的 Isaac Sim 实例和 Isaac Lab 环境。每个进程都会在训练过程中收集自己的滚动数据，并拥有自己的策略网络副本。在训练过程中，梯度会在各进程间汇总，并在历时结束时广播回进程。

        要使用多个 GPU 进行训练，请使用以下命令，其中 --proc_per_node 表示可用 GPU 的数量： 

python -m torch.distributed.run --nnodes=1 --nproc_per_node=2 source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-v0 --headless --distributed

python -m torch.distributed.run --nnodes=1 --nproc_per_node=2 source/standalone/workflows/skrl/train.py --task=Isaac-Cartpole-v0 --headless --distributed

2.2.2 多节点训练

        要扩大单台机器上多个 GPU 的训练规模，也可以跨多个节点进行训练。要跨多个节点/机器进行训练，需要在每个节点上启动一个单独的进程。

        对于主节点，请使用以下命令，其中 --proc_per_node 表示可用 GPU 的数量，而 --nnodes 表示节点的数量：

python -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=0 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=localhost:5555 source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-v0 --headless --distributed

        请注意，端口 (5555) 可替换为任何其他可用端口。

        对于非主节点，请使用以下命令，用每台机器的索引替换 --node_rank 命令：

python -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=1 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=ip_of_master_machine:5555 source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-v0 --headless --distributed

        有关使用 PyTorch 进行多节点训练的详细信息，请访问 PyTorch 文档。

注意事项

        正如 PyTorch 文档中提到的，“多节点训练受节点间通信延迟的制约”。当这种延迟较高时，多节点训练的性能可能会比在单节点实例上运行时更差。

2.3 平铺渲染和录制

2.3.1 平铺渲染

注意事项

        此功能仅在 Isaac Sim 4.0.0 版之后可用。

        平铺渲染需要大量内存资源。我们建议在场景中最多运行 256 个摄像机。

        平铺渲染 API 为从摄像头传感器收集数据提供了一个矢量化接口。这对于需要循环视觉的强化学习环境非常有用。平铺渲染的工作原理是串联多个摄像头的输出，然后渲染一个大图像，而不是每个摄像头生成的多个小图像。这减少了渲染所需的时间，并为处理视觉数据提供了更高效的应用程序接口。

        Isaac Lab 通过 TiledCamera 类为 RGB 和深度数据提供了平铺渲染应用程序接口。平铺渲染 API 的配置可通过 TiledCameraCfg 类进行定义，指定的参数包括所有相机路径的 regex 表达式、相机的变换、所需的数据类型、要添加到场景中的相机类型以及相机分辨率。

tiled_camera: TiledCameraCfg = TiledCameraCfg(
    prim_path="/World/envs/env_.*/Camera",
    offset=TiledCameraCfg.OffsetCfg(pos=(-7.0, 0.0, 3.0), rot=(0.9945, 0.0, 0.1045, 0.0), convention="world"),
    data_types=["rgb"],
    spawn=sim_utils.PinholeCameraCfg(
        focal_length=24.0, focus_distance=400.0, horizontal_aperture=20.955, clipping_range=(0.1, 20.0)
    ),
    width=80,
    height=80,
)

         要访问平铺渲染界面，可以创建一个 TiledCamera 对象，用于从摄像机中获取数据。

tiled_camera = TiledCamera(cfg.tiled_camera)
data_type = "rgb"
data = tiled_camera.data.output[data_type]

        返回的数据将转换为形状（num_cameras、height、width、num_channels），可直接用作强化学习的观测值。

        在进行渲染时，请确保在启动环境时添加 --enable_cameras 参数。例如

python source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-RGB-Camera-Direct-v0 --headless --enable_cameras

2.3.2 训练过程中的录制

        Isaac Lab 支持使用 gymnasium.wrappers.RecordVideo 类在训练期间录制视频片段。

        安装 ffmpeg 并在培训脚本中使用以下命令行参数即可启用此功能：

• --video--在训练过程中启用视频录制
• --video_length--每段录制视频的长度（以步为单位）
• --vide_interval--每次录制视频的间隔时间（以步为单位）

        确保在运行无头系统时也添加 --enable_cameras 参数。请注意，启用录制等同于在训练过程中启用渲染，这会降低启动和运行时的性能。

        使用示例

python source/standalone/workflows/rl_games/train.py --task=Isaac-Cartpole-v0 --headless --video --video_length 100 --video_interval 500

        录制的视频将与训练检查点保存在同一目录下，即 IsaacLab/logs/<rl_workflow>/<task>/<run>/videos/train 目录下。

2.4 环境

        以下列表包含 Isaac Lab 中可用的所有 RL 任务实现。我们会尽量更新此列表，您也可以通过 运行以下命令获得最新的环境列表：

./isaaclab.sh -p source/standalone/environments/list_envs.py

        我们正在积极努力向列表中添加更多环境。如果您有任何希望添加到 Isaac Lab 的环境，请随时开启拉取请求！

2.4.1 经典环境

        基于 IsaacGymEnvs 实现 MuJoCo 风格环境的经典环境。

World	Environment ID	Description
	Isaac-Humanoid-v0 Isaac-Humanoid-Direct-v0	Move towards a direction with the MuJoCo humanoid robot
	Isaac-Ant-v0 Isaac-Ant-Direct-v0	Move towards a direction with the MuJoCo ant robot
	Isaac-Cartpole-v0 Isaac-Cartpole-Direct-v0 Isaac-Cartpole-RGB-Camera-Direct-v0 Isaac-Cartpole-Depth-Camera-Direct-v0	Move the cart to keep the pole upwards in the classic cartpole control

2.4.2 操作

        基于固定手臂操作任务的环境。

        对于其中的许多任务，我们都包含了不同手臂动作空间的配置。例如，在伸手环境中

• Isaac-Lift-Cube-Franka-v0: 带关节位置控制的 Franka 机械臂
• Isaac-Lift-Cube-Franka-IK-Abs-v0：具有绝对 IK 控制功能的 Franka 机械臂
• Isaac-Lift-Cube-Franka-IK-Rel-v0：具有相对 IK 控制功能的 Franka 机械臂

 

World	Environment ID	Description
	Isaac-Reach-Franka-v0	Move the end-effector to a sampled target pose with the Franka robot
	Isaac-Reach-UR10-v0	Move the end-effector to a sampled target pose with the UR10 robot
	Isaac-Lift-Cube-Franka-v0	Pick a cube and bring it to a sampled target position with the Franka robot
	Isaac-Open-Drawer-Franka-v0	Grasp the handle of a cabinet’s drawer and open it with the Franka robot
	Isaac-Repose-Cube-Allegro-v0 Isaac-Repose-Cube-Allegro-Direct-v0	In-hand reorientation of a cube using Allegro hand
	Isaac-Repose-Cube-Shadow-Direct-v0 Isaac-Repose-Cube-Shadow-OpenAI-FF-Direct-v0 Isaac-Repose-Cube-Shadow-OpenAI-LSTM-Direct-v0	In-hand reorientation of a cube using Shadow hand

2.4.3 运动

        基于腿部运动任务的环境。

World	Environment ID	Description
	Isaac-Velocity-Flat-Anymal-B-v0	Track a velocity command on flat terrain with the Anymal B robot
	Isaac-Velocity-Rough-Anymal-B-v0	Track a velocity command on rough terrain with the Anymal B robot
	Isaac-Velocity-Flat-Anymal-C-v0 Isaac-Velocity-Flat-Anymal-C-Direct-v0	Track a velocity command on flat terrain with the Anymal C robot
	Isaac-Velocity-Rough-Anymal-C-v0 Isaac-Velocity-Rough-Anymal-C-Direct-v0	Track a velocity command on rough terrain with the Anymal C robot
	Isaac-Velocity-Flat-Anymal-D-v0	Track a velocity command on flat terrain with the Anymal D robot
	Isaac-Velocity-Rough-Anymal-D-v0	Track a velocity command on rough terrain with the Anymal D robot
	Isaac-Velocity-Flat-Unitree-A1-v0	Track a velocity command on flat terrain with the Unitree A1 robot
	Isaac-Velocity-Rough-Unitree-A1-v0	Track a velocity command on rough terrain with the Unitree A1 robot
	Isaac-Velocity-Flat-Unitree-Go1-v0	Track a velocity command on flat terrain with the Unitree Go1 robot
	Isaac-Velocity-Rough-Unitree-Go1-v0	Track a velocity command on rough terrain with the Unitree Go1 robot
	Isaac-Velocity-Flat-Unitree-Go2-v0	Track a velocity command on flat terrain with the Unitree Go2 robot
	Isaac-Velocity-Rough-Unitree-Go2-v0	Track a velocity command on rough terrain with the Unitree Go2 robot
	Isaac-Velocity-Flat-Spot-v0	Track a velocity command on flat terrain with the Boston Dynamics Spot robot
	Isaac-Velocity-Flat-H1-v0	Track a velocity command on flat terrain with the Unitree H1 robot
	Isaac-Velocity-Rough-H1-v0	Track a velocity command on rough terrain with the Unitree H1 robot
	Isaac-Velocity-Flat-G1-v0	Track a velocity command on flat terrain with the Unitree G1 robot
	Isaac-Velocity-Rough-G1-v0	Track a velocity command on rough terrain with the Unitree G1 robot

2.4.4 导航

World	Environment ID	Description
	Isaac-Navigation-Flat-Anymal-C-v0	Navigate towards a target x-y position and heading with the ANYmal C robot.

2.4.5 其他

World	Environment ID	Description
	Isaac-Quadcopter-Direct-v0	Fly and hover the Crazyflie copter at a goal point by applying thrust.

2.5 驱动器

        铰接系统由驱动器关节组成，也称为自由度 (DOF)。在物理系统中，驱动器通常通过主动组件（如电动或液压马达）或被动组件（如弹簧）来实现。这些组件可引入某些非线性特性，包括延迟或最大可产生速度或扭矩。

        在仿真中，关节可以由位置、速度或扭矩控制。对于位置和速度控制，物理引擎在内部执行弹簧阻尼（PD）控制器，计算施加在驱动器关节上的扭矩。在力矩控制中，命令直接设置为关节的作用力。虽然这模拟了关节机构的理想行为，但并不能真正模拟驱动在物理世界中的工作方式。因此，我们提供了一种注入外部模型的机制，以计算代表物理机器人行为的关节指令。

2.5.1 驱动器模型

        我们命名了两种不同类型的驱动器模型：

1. 隐式：对应于理想的仿真机制（由物理引擎提供）。
2. 显式：对应外部驱动模型（由用户实现）。

        显式驱动器模型执行两个步骤： 1) 计算用于跟踪输入指令的所需关节扭矩，以及 2) 根据电机能力剪切所需的扭矩。剪切后的扭矩就是设置到仿真中的所需驱动器力度。

        作为理想显式驱动器模型的示例，我们提供了 omni.isaac.lab.actuators.IdealPDActuator 类，该类实现了具有前馈作用力的 PD 控制器，并根据配置的最大作用力进行简单剪切：

 2.5.2 驱动器组

        驱动器模型本身是一个计算模块，它将所需的关节指令作为输入，并输出应用到仿真器中的关节指令。这些模型本身并不包含任何有关其作用关节的知识。这些知识由 omni.isaac.lab.assets.Articulation 类处理，该类封装在物理引擎的关节类中。

        驱动器被收集为铰接上使用相同驱动器模型的一组执行关节。例如，四足动物 ANYmal-C 的所有关节都使用系列弹性驱动器 ANYdrive 3.0。该分组可为这些关节配置驱动器模型，将输入指令转换为关节级指令，并将铰接动作返回设置到仿真器中。如果手臂使用不同的驱动器模型，如直流电机，则需要配置不同的驱动器组。

        下图显示了腿式移动机械手的驱动器组：

另请参见

        我们提供各种显式驱动器模型的实现。这些在 omni.isaac.lab.actuators 子软件包中有详细说明。