Base Command Platform
1. NVIDIA Base Command Platform 简介
NVIDIA Base Command Platform 是一个全面的平台，面向企业、其数据科学家和 IT 团队，以即用型云托管解决方案形式提供，用于管理 AI 开发、AI 工作流程和资源管理的端到端生命周期。
NVIDIA Base Command Platform 提供：
一套云托管工具，使数据科学家能够访问 AI 基础设施，而不会相互干扰。
一个全面的基于云的 UI 和完整的命令行 API，可使用从单个 GPU 到具有数据集管理的多节点集群的适当大小的资源高效执行 AI 工作负载，从而快速交付可用于生产的模型和应用程序。
一个内置的遥测功能，用于验证深度学习技术、工作负载设置和资源分配，作为持续改进过程的一部分。
为希望根据业务目标衡量 AI 项目的业务领导者以及需要设置项目优先级并通过正确预测计算能力需求来规划成功未来的团队经理提供报告和退款能力。
1.1. NVIDIA Base Command Platform 术语和概念
以下是本文档中使用的常见 NVIDIA Base Command Platform 术语的描述。
术语 |
定义 |
|---|---|
加速计算环境 (ACE) |
ACE 是一个集群或一个可用区。每个 ACE 都有单独的存储、计算和网络。 |
NGC 目录 |
NGC 目录是由 NVIDIA 维护并可供公众访问的精选 GPU 优化软件集。 它由容器、预训练模型、Kubernetes 部署的 Helm chart 以及带有软件开发工具包 (SDK) 的行业特定 AI 工具包组成。 |
容器镜像 |
NGC 中运行的所有应用程序都容器化为 Docker 容器，并在我们的运行时环境中执行。容器存储在 NGC 容器注册表 nvcr.io 中，可从 CLI 和 Web UI 访问。 |
容器端口 |
在创建作业时打开端口将创建一个 URL，该 URL 可用于使用 Web 协议访问该端口上的容器。以这种方式访问的 Web 应用程序（例如 Jupyterlab）的安全性由用户负责。请参阅下面的注释。 |
数据集 |
数据集是作业的数据输入，以只读方式挂载到作业中指定的位置。它们可以包含数据或代码。数据集在数据集部分中详细介绍。 |
数据结果 |
结果是作业指定的读写挂载，并由系统捕获。写入结果的所有数据在作业完成后都可用，以及 stdout 和 stderr 的内容。 |
实例 |
实例决定了作业可用的 CPU 核心数、RAM 大小以及 GPU 的类型和数量。根据 ACE，可以使用一到八个 GPU 的实例类型。 |
作业 |
作业是计算的基本单元 - 在 ACE 中运行 NVIDIA Base Command Platform 实例的容器。作业由提交时指定的一组属性定义。 |
作业定义 |
定义作业的属性。 |
作业命令 |
每个作业都可以指定在容器内运行的命令。该命令可以根据需要简单或复杂，只要正确转义引号即可。 |
作业 - 多节点 |
在多个节点上运行的作业。 |
模型 |
NGC 提供了一系列最先进的预训练深度学习模型，这些模型可以轻松地开箱即用、重新训练或微调。 |
组织 |
具有自己注册表空间的企业组织。用户被分配（或属于）到一个组织。 |
团队 |
组织内的子单元，具有自己的注册表空间。只有同一团队的成员才能访问该团队的注册表空间。 |
用户 |
任何拥有 Base Command Platform 帐户的人。用户被分配到一个组织。 |
私有注册表 |
NGC 私有注册表为您提供了一个安全空间，用于在企业内存储和共享自定义容器、模型、资源和 Helm chart。 |
配额 |
每个用户都被分配了默认的 GPU 和存储配额。GPU 配额定义了用户帐户使用的最大并发 GPU 数量。每个用户都分配了默认的初始存储配额。您的存储资产（数据集、结果和工作区）计入您的存储配额。 |
资源 |
NGC 提供了逐步说明和脚本，用于创建您可以在团队或组织内共享的深度学习模型。 |
遥测 |
Base Command Platform 提供了从各种系统组件（如 GPU、Tensor Core、CPU、内存和 I/O）收集的时间序列指标数据。 |
工作区 |
工作区是可共享的读写持久存储，可在作业中挂载以供并发使用。在作业中以读写模式（默认模式）挂载工作区非常适合用作检查点文件夹。工作区也可以以只读模式挂载到作业，使其非常适合在知道作业不会损坏/修改任何数据的情况下用于配置/代码/输入用例。 |
1.1.1. 安全注意事项
用户作业和容器托管的 Web 应用程序（例如 JupyterLab）的安全性由客户负责。Base Command Platform 提供了一个唯一的 URL 来访问此 Web 应用程序，并且任何拥有该 URL 的用户都可以访问该应用程序。以下是一些保护您的 Web 应用程序的建议：
实施适当的身份验证机制以保护您的应用程序。
默认情况下，我们使用 nvbcp.com 下的子域，这是一个共享域，如果您使用基于 Cookie 的身份验证，建议您针对您的 FQDN 设置 Cookie，而不仅仅是子域。
如果内部用户访问该应用程序，您可以限制仅从您的公司网络、防火墙和 VPN 后进行访问。
将 URL 视为机密，并且仅与授权用户共享（除非您已如上文 (1) 中所述实施适当的身份验证控制）。
2. 入门和注册
本章将引导您完成设置 NVIDIA Base Command 帐户的过程。在本章中，您将学习注册、登录、安装和配置 CLI 以及选择和切换您的团队上下文。
2.1. 邀请用户
本节面向组织或团队管理员（具有用户管理员角色），并描述了邀请（添加）用户到 NVIDIA Base Command Platform 的过程。
作为组织管理员，您必须创建用户帐户，以允许其他人在组织内使用 NVIDIA Base Command Platform。
登录到 NGC Web UI，然后选择与 NVIDIA Base Command Platform 关联的 NGC 组织。
从左侧导航菜单中单击组织 > 用户。
此功能仅适用于用户管理员。
单击页面右上角的邀请新用户。
在新页面上，填写用户信息部分。为名字输入您的屏幕名称，并输入接收邀请电子邮件的电子邮件地址。
在角色部分中，选择适当的上下文（组织或特定团队）以及下面框中显示的可用角色。单击右侧的添加角色以保存您的更改。您可以在创建用户之前添加或删除多个角色。
以下是用户角色的简要说明：
NVIDIA Base Command Platform 角色 角色
描述
Base Command 管理员
具有管理 Base Command Platform 中所有可用工件的功能的管理员角色。管理员角色的功能包括资源分配和访问管理。
Base Command 查看者
具有对用户组织或团队中的作业、工作区、数据集和结果的只读访问权限的管理员角色。
注册表管理员
用于管理 NGC 私有注册表工件并具有注册表用户管理功能的注册表管理员角色。注册表管理员角色的功能包括所有注册表角色的功能。
注册表读取
仅具有使用私有注册表工件的功能的注册表用户角色。
注册表用户
具有发布和使用私有注册表工件的功能的注册表用户角色。
用户管理员
仅具有管理用户功能的的用户管理员角色。
有关更多信息，请参阅 分配角色 部分。
添加角色后，仔细检查所有字段，然后单击右上角的创建用户。邀请电子邮件将自动发送给用户。
仍需要接受邀请电子邮件的用户显示在用户页面上的待处理邀请列表中。
2.2. 加入 NGC 组织或团队
在使用 NVIDIA Base Command Platform 之前，您必须拥有由您的组织管理员创建的 NVIDIA Base Command Platform 帐户。您需要一个电子邮件地址来设置帐户。激活帐户取决于您的电子邮件域是否映射到您组织的单点登录 (SSO)。根据您的具体情况，选择以下过程之一来激活您的 NVIDIA Base Command Platform 帐户。
2.2.1. 使用单点登录加入 NGC 组织或团队
本节介绍激活电子邮件地址域映射到组织单点登录的帐户。
在 NVIDIA 或您的组织管理员将您添加到组织内的新组织或团队后，您将收到一封欢迎电子邮件，邀请您继续激活和登录过程。
单击电子邮件中的链接以打开您组织的单点登录页面。
使用您的单点登录凭据登录。
将出现设置您的组织屏幕。
此屏幕在您每次登录时都会出现。
选择您要登录的组织和团队，然后单击继续。
登录后，您可以随时更改为您所属的其他组织或团队。
NGC Web UI 打开Base Command 仪表板。
2.2.2. 使用新的 NVIDIA 帐户加入组织或团队
本节介绍激活电子邮件地址域未映射到组织单点登录的新帐户。
在 NVIDIA 或您的组织管理员设置您的 NVIDIA Base Command 帐户后，您将收到一封欢迎电子邮件，邀请您继续激活和登录过程。
单击“登录”链接以在浏览器中打开登录对话框。
填写您的信息，创建密码，同意条款和条件，然后单击创建帐户。
您需要验证您的电子邮件。
验证电子邮件已发送。
打开电子邮件，然后单击验证电子邮件地址。
选择您使用推荐设置和接收开发者新闻和公告的选项，然后单击提交。
同意 NVIDIA 帐户使用条款，选择所需的选项，然后单击继续。
在NVIDIA GPU Cloud 使用条款屏幕上单击接受。
将出现“设置您的组织”屏幕。
此屏幕在您每次登录时都会出现。
选择您要登录的组织和团队，然后单击继续。
登录后，您可以随时更改为您所属的其他组织或团队。
NGC Web UI 打开Base Command 仪表板。
2.2.3. 使用现有的 NVIDIA 帐户加入组织或团队
本节介绍激活电子邮件地址域未映射到组织单点登录 (SSO) 的帐户。
在 NVIDIA 或您的组织管理员将您添加到组织内的新组织或团队后，您将收到一封欢迎电子邮件，邀请您继续激活和登录过程。
单击“登录”链接以在浏览器中打开登录对话框。
输入您的密码，然后单击登录。
将出现“设置您的组织”屏幕。
此屏幕在您每次登录时都会出现。
选择您要登录的组织和团队，然后单击继续。
登录后，您可以随时更改为您所属的其他组织或团队。
NGC Web UI 打开Base Command 仪表板。
3. 登录您的帐户
在初始帐户设置期间，您已登录到 NGC 网站上的 NVIDIA Base Command Platform 帐户。本节介绍稍后发生的登录过程。它还在较高层面上描述了 NVIDIA Base Command Platform 的 Web UI 部分，包括用于访问可用工件的 UI 区域以及各种用户角色可用的操作。
打开 https://ngc.nvidia.com 并根据您的帐户单击其中一个登录选项的继续。
NVIDIA 帐户：如果单点登录 (SSO) 不可用，请选择此选项。
单点登录 (SSO)：选择此选项以使用您组织的 SSO。您可能需要与您的组织或 Base Command Platform 管理员确认是否已启用 SSO。
继续使用您组织的单点登录进行登录。
设置您希望登录的组织，然后单击继续。
登录后，您可以随时更改为您所属的其他组织或团队。
下图和表格描述了网站左侧导航菜单中的主要功能，包括用于更改组织或团队的控件。
ID |
描述 |
|---|---|
1 |
目录：单击此菜单以访问精选的 GPU 优化软件集。它由容器、预训练模型、Kubernetes 部署的 Helm chart 以及行业特定的 AI 工具包和软件开发工具包 (SDK) 组成，这些工具包和 SDK 由 NVIDIA 定期发布，并且对于 Base Command Platform 用户而言是只读的。 |
2 |
私有注册表：单击此菜单以访问安全空间，用于在您的企业内存储和共享自定义容器、模型、资源和 Helm chart。 |
3 |
BASE COMMAND：单击此菜单以访问用于创建和运行 Base Command Platform 作业的控件。 |
4 |
组织：（仅限用户管理员）单击此菜单以管理用户和团队。 |
5 |
用户信息：选择此下拉列表以查看用户信息，选择要操作的组织，以及下载 NGC CLI 和 API 密钥，这将在本文档的后面部分介绍。 |
6 |
团队选择：选择此下拉列表以选择要操作的团队。 |
4. NGC CLI 简介
本章介绍 NGC Base Command Platform CLI，它可安装在您的工作站上，用于与 Base Command Platform 交互。在本节中，您将学习适用于所有命令的 CLI 通用功能，以及映射到您在前一章中学习的 Web UI 区域的 CLI 模块。
NGC Base Command Platform CLI 是一个命令行界面，用于管理 NGC 注册表中的内容以及与 NVIDIA Base Command Platform 交互。CLI 在 shell 中运行，并允许您使用脚本来自动化命令。
使用 NGC Base Command Platform CLI，您可以连接到：
NGC 目录
NGC 私有注册表
用户管理（仅适用于组织或团队用户管理员）
NVIDIA Base Command Platform 工作负载和实体
4.1. 关于 NVIDIA Base Command Platform 的 NGC CLI
如果您使用自己的 NGC 帐户或 NVIDIA Base Command Platform 帐户登录，则可以使用 NGC CLI，并且可以使用它来：
查看可供您使用的 GPU 加速 Docker 容器列表以及有关每个容器镜像的详细信息。
查看深度学习模型和资源列表以及有关它们的详细信息。
下载容器镜像、模型和资源。
上传并选择性地共享容器镜像、模型和资源。
创建和管理用户和团队（适用于管理员）。
从 NGC 注册表启动和管理作业。
下载、上传并选择性地共享作业的数据集。
创建和管理工作区以供作业中使用。
4.2. 生成您的 NGC API 密钥
本节介绍如何获取配置 CLI 应用程序所需的 API 密钥，以便您可以使用 CLI 访问 NGC 目录中的锁定容器镜像、访问 NGC 私有注册表中的内容、管理存储实体以及启动作业。
NGC API 密钥也用于 Docker 登录，以便使用 Docker 客户端管理 NGC 私有注册表中的容器镜像。
登录到 NGC Web UI。
从浏览器中，转到 NGC 登录页面，然后输入您的电子邮件。
单击使用企业帐户登录登录选项的继续。
输入您组织的凭据。
在右上角，单击您的用户帐户图标，然后选择一个属于 NVIDIA Base Command Platform 帐户的组织。
再次单击您的用户帐户图标，然后选择设置。
单击获取 API 密钥以打开设置 > API 密钥页面。
单击获取 API 密钥以生成您的 API 密钥。将出现警告消息，告知您如果创建新密钥，您的旧 API 密钥将失效。
单击确认以生成密钥。
您的 API 密钥将出现。
您只需要生成一次 API 密钥。NGC 不会保存您的密钥，因此请将其存储在安全的地方。（您可以通过单击 API 密钥右侧的复制图标将您的 API 密钥复制到剪贴板。）
如果您丢失了 API 密钥，您可以从 NGC 网站生成一个新的密钥。当您生成新的 API 密钥时，旧的密钥将失效。
4.3. 安装 NGC CLI
要安装 NGC CLI，请执行以下操作：
登录到 NGC 网站上的 NVIDIA Base Command Platform 帐户 (https://ngc.nvidia.com)。
在右上角，单击您的用户帐户图标，然后选择一个属于 Base Command Platform 帐户的组织。
从用户帐户菜单中，选择设置，然后从“设置”页面单击 CLI 下的下载。
从“CLI 安装”页面，根据您将从中运行 NGC CLI 的平台，单击 Windows、Linux 或 macOS 选项卡。
按照您选择的操作系统部分中显示的安装说明进行操作。
通过输入
ngc --version验证安装。输出应为NGC CLI x.y.z，其中x.y.z表示版本。
4.4. 获取使用 NGC CLI 的帮助
本节介绍如何获取使用 NGC CLI 的帮助。
注意
ngc batch 命令已替换为 ngc base-command 或简写 ngc bc。新命令提供与其前身相同的功能。请注意，旧的 ngc batch 命令现在已弃用，将在未来的版本中逐步淘汰。
4.4.1. 从命令行获取帮助
要运行 NGC CLI 命令，请输入 ngc，后跟适当的选项。
要查看可用选项和命令描述的描述，请在任何命令或选项后使用选项 -h。
示例 1：要查看 ngc 命令的所有可用选项列表，请输入：
$ ngc -h
示例 2：要查看所有 ngc base-command 命令和选项的描述，请输入：
$ ngc base-command -h
示例 3：要查看 dataset 命令的描述，请输入：
$ ngc dataset -h
4.4.2. 在线查看 NGC CLI 文档
NGC Base Command Platform CLI 文档 提供了所有 NGC Base Command Platform CLI 命令和参数的参考。您还可以通过从用户下拉列表中选择设置，然后单击 CLI 窗格中的文档来从 NGC Web UI 访问 CLI 文档。
4.5. 配置 CLI 以供您使用
要充分利用 NGC Base Command Platform CLI，您必须使用 ngc config set 命令使用您的 API 密钥对其进行配置。
虽然您可以为每个命令使用选项来指定组织和团队，以及输出类型和调试模式，但您也可以使用 ngc config set 命令预先建立这些设置。
如果您有预先存在的设置，您可以使用以下命令检查当前配置：
$ ngc config current
要配置 CLI 以供您使用，请发出以下命令：
$ ngc config set
Enter API key. Choices: [<VALID_APIKEY>, 'no-apikey']:
Enter CLI output format type [ascii]. Choices: [ascii, csv, json]:
Enter org [nv-eagledemo]. Choices: ['nv-eagledemo']:
Enter team [nvtest-repro]. Choices: ['nvtest-repro, 'no-team']:
Enter ace [nv-eagledemo-ace]. Choices: ['nv-eagledemo-ace', 'no-ace']:
Successfully saved NGC configuration to C:\Users\jsmith\.ngc\config
如果您是多个组织或团队的成员，请确保选择与 NVIDIA Base Command Platform 关联的组织或团队。
4.5.1. 配置输出格式
您可以使用 --format_type <fmt> 参数在发出命令时配置输出格式。如果您想使用与默认 ascii 不同的格式，或者与您运行 ngc config set 时设置的格式不同，这将非常有用。
以下是每种输出格式的示例。
Ascii
$ ngc base-command list --format_type ascii
+---------+----------+--------------+------+------------------+----------+----------------+
| Id | Replicas | Name | Team | Status | Duration | Status Details |
+---------+----------+--------------+------+------------------+----------+----------------+
| 1893896 | 1 | helloworld | ngc | FINISHED_SUCCESS | 0:00:00 | |
CSV
$ ngc base-command list --format_type csv
Id,Replicas,Name,Team,Status,Duration,Status Details
1893896,1,helloworld ml-model.exempt-qsg,ngc,FINISHED_SUCCESS,0:00:00,
JSON
$ ngc base-command list --format_type json
[{
"aceId": 257,
"aceName": "nv-us-west-2",
"aceProvider": "NGN",
"aceResourceInstance": "dgx1v.16g.1.norm",
"createdDate": "2021-04-08T01:20:05.000Z",
"id": 1893896,
"jobDefinition": {
…
},
"jobStatus": {
…
],
"submittedByUser": "John Smith",
"submittedByUserId": 28166,
"teamName": "ngc"
}]
4.6. 运行诊断程序
诊断信息可用于提供详细信息以帮助隔离问题。向 NVIDIA 支持部门报告 CLI 问题时，您可以提供此信息。
以下诊断信息适用于 NGC Base Command Platform CLI 用户：
当前时间
操作系统
磁盘使用情况
当前目录大小
内存使用情况
NGC CLI 安装
NGC CLI 环境变量（是否已设置）
NGC CLI 配置值
API 网关连接
与容器注册表和模型注册表的 API 连接
数据存储连接
Docker 运行时信息
外部 IP
用户信息（ID、姓名和电子邮件）
用户组织角色
用户团队角色
语法
$ ngc diag [all,client,install,server,user]
其中：
all
生成最大量的诊断输出。
client
仅为客户端计算机生成诊断输出。
install
仅为本地安装生成诊断输出。
server
仅为远程服务器生成诊断输出。
user
仅为用户配置生成诊断输出。
4.7. 指定列表列
某些命令提供列表，例如注册表镜像列表或批处理作业列表。
示例
ngc base-command list
ngc dataset list
ngc registry image list
ngc registry model list
ngc registry resource list
ngc workspace list
默认信息包括多列信息，这些信息可能会显得杂乱，尤其是在您对所有信息都不感兴趣的情况下。
例如，ngc base-command list 命令提供以下列：
+----+----------+------+------+--------+----------+----------------+
| Id | Replicas | Name | Team | Status | Duration | Status Details |
+----+----------+------+------+--------+----------+----------------+
您可以使用 --column 参数将输出限制为仅显示您指定的列。
例如，要仅显示名称、团队和状态，请输入：
$ ngc base-command list --column name --column team --column status
+----+------+------+--------+
| Id | Name | Team | Status |
+----+------+------+--------+
注意
“Id”列将始终显示，无需指定。
请查阅 --column 参数的帮助，以确定每列要使用的确切值。
4.8. 其他有用的命令选项
4.8.1. 自动交互式命令处理
使用 -y 参数插入对所有交互式问题的“yes”(y) 响应。
示例:
$ ngc workspace share --team <team> -y <workspace>
4.8.2. 测试命令
某些命令支持 --dry-run 参数。此参数生成描述命令预期结果的输出。
示例:
$ ngc result remove 1893896 --dry-run
Would remove result for job ID: 1893896 from org: <org>
使用 -h 参数查看特定命令是否支持 --dry-run 参数。
5. 使用 NGC API
本节提供如何使用 NGC Base Command Platform API 的示例。有关 API 的详细列表，请参阅 NGC API 文档。
5.1. 获取基本作业信息的示例
此示例显示如何获取基本作业信息。它显示了 API 方法，用于执行与 NGC Base Command Platform CLI 命令对应的步骤：
ngc base-command get-json {job-id}
5.1.1. 使用 Get 请求
以下是使用 API Get 请求的流程。
获取有效授权。
发送 GET 请求至
https://authn.nvidia.com/token以获取有效令牌。获取作业信息。
发送 GET 请求至
https://api.ngc.nvidia.com/v2/org/{org-name}/jobs/{job-id}，并附带从第一个请求返回的令牌。另一个询问步骤。
5.1.2. 获取令牌的代码示例
以下是获取有效授权（令牌）的代码示例。
注意
API_KEY 是从 NGC Web UI 获取的密钥，如果您使用过 CLI，则应存在于您的 NGC 配置文件中。
#!/usr/bin/python3
import os, base64, json, requests
def ngc_get_token(org='nv-eagledemo', team=None):
'''Use the api key set environment variable to generate auth token'''
scope = f'group/ngc:{org}'
if team: #shortens the token if included
scope += f'/{team}'
querystring = {"service": "ngc", "scope": scope}
auth = '$oauthtoken:{0}'.format(os.environ.get('API_KEY'))
headers = {
'Authorization': 'Basic {}'.format(base64.b64encode(auth.encode('utf-8')).decode('utf-8')),
'Content-Type': 'application/json',
'Cache-Control': 'no-cache',
}
url = 'https://authn.nvidia.com/token'
response = requests.request("GET", url, headers=headers, params=querystring)
if response.status_code != 200:
raise Exception("HTTP Error %d: from '%s'" % (response.status_code, url))
return json.loads(response.text.encode('utf8'))["token"]
身份验证响应的示例输出
{
"token": "eyJraW...",
"expires_in": 600
}
5.1.3. 获取作业信息的代码示例
令牌是“获取令牌”部分中函数的输出。
def ngc_get_jobinfo(token=None, jobid=None, org=None):
url = f'https://api.ngc.nvidia.com/v2/org/{org}/jobs/{jobid}'
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
response = requests.request("GET", url, headers=headers)
if response.status_code != 200:
raise Exception("HTTP Error %d: from '%s'" % (response.status_code, url))
return response.json()
作业信息的输出
{
"job": {
"aceId": 357,
"aceName": "nv-eagledemo-ace",
"aceProvider": "NGN",
"aceResourceInstance": "dgxa100.40g.1.norm",
"createdDate": "2021-06-04T16:14:31.000Z",
"datasets": [],
"gpuActiveTime": 1,
"gpuUtilization": 0,
"id": 2039271,
"jobDefinition": {
"aceId": 357,
"clusterId": "eagle-demo.nvk8s.com",
"command": "set -x; jupyter lab --NotebookApp.token='' --notebook-dir=/ --NotebookApp.allow_origin='*' & date; nvidia-smi; echo $NVIDIA_BUILD_ID; sleep 1d",
"datasetMounts": [],
"dockerImage": "nvidia/pytorch:21.02-py3",
"jobDataLocations": [
{
"accessRights": "RW",
"mountPoint": "/result",
"protocol": "NFSV3",
"type": "RESULTSET"
},
{
"accessRights": "RW",
"mountPoint": "/result",
"protocol": "NFSV3",
"type": "LOGSPACE"
}
],
"jobType": "BATCH",
"name": "NVbc-jupyterlab",
"portMappings": [
{
"containerPort": 8888,
"hostName": "https://kpog9271.eagle-demo.proxy.ace.ngc.nvidia.com",
"hostPort": 0
}
],
"replicaCount": 1,
"resources": {
"cpuCores": 30,
"gpus": 1,
"name": "dgxa100.40g.1.norm",
"systemMemory": 124928
},
"resultContainerMountPoint": "/result",
"runPolicy": {
"minTimesliceSeconds": 3600,
"preemptClass": "RESUMABLE",
"totalRuntimeSeconds": 72000
},
"useImageEntryPoint": false,
"workspaceMounts": []
},
"jobStatus": {
"containerName": "6a977c9461f228b875b800acd6ced1b9a14905a46fca62c5bdbc393409bebe2d",
"createdDate": "2021-06-04T20:05:19.000Z",
"jobDataLocations": [
{
"accessRights": "RW",
"mountPoint": "/result",
"protocol": "NFSV3",
"type": "RESULTSET"
},
{
"accessRights": "RW",
"mountPoint": "/result",
"protocol": "NFSV3",
"type": "LOGSPACE"
}
],
"portMappings": [
{
"containerPort": 8888,
"hostName": "https://kpog9271.eagle-demo.proxy.ace.ngc.nvidia.com",
"hostPort": 0
}
],
"resubmitId": 0,
"selectedNodes": [
{
"ipAddress": "ww.x.yy.zz",
"name": "node-02",
"serialNumber": "ww.x.yy.zz"
}
],
"startedAt": "2021-06-04T16:14:42.000Z",
"status": "RUNNING",
"statusDetails": "",
"statusType": "OK",
"totalRuntimeSeconds": 14211
},
"lastStatusUpdatedDate": "2021-06-04T20:05:19.000Z",
"orgName": "nv-eagledemo",
"resultset": {
"aceName": "nv-eagledemo-ace",
"aceStorageServiceUrl": "https://nv-eagledemo.dss.ace.ngc.nvidia.com",
"createdDate": "2021-06-04T16:14:31.000Z",
"creatorUserId": "99838",
"creatorUserName": "K Kris",
"id": "2039271",
"orgName": "nv-eagledemo",
"owned": true,
"shared": false,
"sizeInBytes": 2662,
"status": "COMPLETED",
"updatedDate": "2021-06-04T20:05:19.000Z"
},
"submittedByUser": "K Kris",
"submittedByUserId": 99838,
"teamName": "nvbc-tutorials",
"workspaces": []
},
"jobRequestJson": {
"dockerImageName": "nvidia/pytorch:21.02-py3",
"aceName": "nv-eagledemo-ace",
"name": "NVbc-jupyterlab",
"command": "set -x; jupyter lab --NotebookApp.token\\u003d\\u0027\\u0027 --notebook-dir\\u003d/ --NotebookApp.allow_origin\\u003d\\u0027*\\u0027 \\u0026 date; nvidia-smi; echo $NVIDIA_BUILD_ID; sleep 1d",
"replicaCount": 1,
"publishedContainerPorts": [
8888
],
"runPolicy": {
"minTimesliceSeconds": 3600,
"totalRuntimeSeconds": 72000,
"preemptClass": "RESUMABLE"
},
"workspaceMounts": [],
"aceId": 357,
"datasetMounts": [],
"resultContainerMountPoint": "/result",
"aceInstance": "dgxa100.40g.1.norm"
},
"jobStatusHistory": [
{
"containerName": "6a977c9461f228b875b800acd6ced1b9a14905a46fca62c5bdbc393409bebe2d",
"createdDate": "2021-06-04T20:05:19.000Z",
"jobDataLocations": [],
"portMappings": [
{
"containerPort": 8888,
"hostName": "https://kpog9271.eagle-demo.proxy.ace.ngc.nvidia.com",
"hostPort": 0
}
],
"resubmitId": 0,
"selectedNodes": [
{
"ipAddress": "10.0.66.70",
"name": "node-02",
"serialNumber": "10.0.66.70"
}
],
"startedAt": "2021-06-04T16:14:42.000Z",
"status": "RUNNING",
"statusDetails": "",
"statusType": "OK",
"totalRuntimeSeconds": 14212
},
{
"createdDate": "2021-06-04T16:14:39.000Z",
"jobDataLocations": [],
"portMappings": [
{
"containerPort": 8888,
"hostName": "",
"hostPort": 0
}
],
"resubmitId": 0,
"selectedNodes": [
{
"ipAddress": "10.0.66.70",
"name": "node-02",
"serialNumber": "10.0.66.70"
}
],
"status": "STARTING",
"statusDetails": "",
"statusType": "OK"
},
{
"createdDate": "2021-06-04T16:14:36.000Z",
"jobDataLocations": [],
"portMappings": [
{
"containerPort": 8888,
"hostName": "",
"hostPort": 0
}
],
"resubmitId": 0,
"selectedNodes": [],
"status": "QUEUED",
"statusDetails": "Resources Unavailable",
"statusType": "OK"
},
{
"jobDataLocations": [],
"selectedNodes": [],
"status": "CREATED"
}
],
"requestStatus": {
"requestId": "f7fbc3ff-36cf-4676-84a0-3d332b4091b1",
"statusCode": "SUCCESS"
}
}
5.1.4. 获取遥测数据的代码示例
令牌是“获取令牌”部分的输出。
#!/usr/bin/python3
# INFO: Before running this you must run 'export API_KEY=<ngc api key>' in your terminal
import os, json, base64, requests
def get_token(org='nv-eagledemo', team=None):
'''Use the api key set environment variable to generate auth token'''
scope = f'group/ngc:{org}'
if team: #shortens the token if included
scope += f'/{team}'
querystring = {"service": "ngc", "scope": scope}
auth = '$oauthtoken:{0}'.format(os.environ.get('API_KEY'))
auth = base64.b64encode(auth.encode('utf-8')).decode('utf-8')
headers = {
'Authorization': f'Basic {auth}',
'Content-Type': 'application/json',
'Cache-Control': 'no-cache',
}
url = 'https://authn.nvidia.com/token'
response = requests.request("GET", url, headers=headers, params=querystring)
if response.status_code != 200:
raise Exception("HTTP Error %d: from '%s'" % (response.status_code, url))
return json.loads(response.text.encode('utf8'))["token"]
def get_job(job_id, org, team, token):
'''Get general information for a specific job'''
url = f'https://api.ngc.nvidia.com/v2/org/{org}/jobs/{job_id}'
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
response = requests.request("GET", url, headers=headers)
if response.status_code != 200:
raise Exception("HTTP Error %d: from '%s'" % (response.status_code, url))
return response.json()
def get_telemetry(job_id, start, end, org, team, token):
'''Get telemetry information for a specific job'''
url = f'https://api.ngc.nvidia.com/v2/org/{org}/jobs/{job_id}/telemetry'
# INFO: See the docs for full list of telemetry
vals = {
'measurements': [
{
"type":"APPLICATION_TELEMETRY",
"aggregation":"MEAN",
"toDate": end,
"fromDate": start,
"period":60
},{
"toDate": end,
"period": 60,
"aggregation": "MEAN",
"fromDate": start,
"type": "GPU_UTILIZATION"
}]
}
params = {'q': json.dumps(vals)}
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
response = requests.request("GET", url, params=params, headers=headers)
if response.status_code != 200:
raise Exception("HTTP Error %d: from '%s'" % (response.status_code, url))
return response.json()
# Get org/team information from account setup
org = 'nv-eagledemo'
team='nvbc-tutorials'
# Get job ID from GUI, CLI, or other API calls
job_id = 'TODO'
# Generate a token
token = get_token(org, team)
print(token)
# Get general job info for the job of interest
job_info = get_job(job_id, org, team, token)
print(json.dumps(job_info, indent=4, sort_keys=True))
# Get all job telemetry for the job of interest
telemetry = get_telemetry(job_id,
job_info['job']['createdDate'],
job_info['job']['jobStatus']['endedAt'],
org, team, token)
print(json.dumps(telemetry, indent=4, sort_keys=True))
5.2. API 端点列表
通过在 CLI 中使用 --debug 标志，您可以查看给定命令使用了哪些端点和参数。
列出的端点全部用于 GET 请求，但其他方法（POST、PATCH 等）也支持不同的功能。更多信息请见此处：https://docs.ngc.nvidia.com/api/
部分 |
端点 |
描述 |
|---|---|---|
用户管理 |
/v2/users/me |
获取与您的用户相关的信息，例如您可以在其中访问的所有团队、数据集和工作空间中的角色 |
用户管理 |
/v2/org/{org-name}/teams/{team-name} |
获取 {team-name} 的描述和 ID |
用户管理 |
/v2/org/{org-name}/teams |
获取您在 {org-name} 中的团队列表 |
用户管理 |
/v2/orgs |
获取您可以访问的组织列表 |
作业 |
/v2/org/{org-name}/jobs/{id} |
获取有关作业的详细信息，包括所有创建作业选项和状态历史记录 |
作业 |
/v2/org/{org-name}/jobs |
获取作业列表 |
作业 |
/v2/org/{org-name}/jobs/* |
以上链接中还有更多作业命令，可用于控制作业 |
数据集 |
/v2/org/{org-name}/datasets |
获取 {org-name} 中可访问的数据集列表 |
数据集 |
/v2/org/{org-name}/datasets/{id} |
获取有关数据集的信息，包括其文件列表 |
数据集 |
/v2/org/{org-name}/datasets/{id}/file/** |
从数据集下载文件 |
遥测 |
/v2/org/{org-name}/jobs/{id}/telemetry |
获取有关作业的遥测信息。 |
遥测 |
/v2/org/{org-name}/measurements/jobs/{id}/[cpu|gpu|memory]/[allocation|utilization] |
用于特定类型遥测信息的单独端点 |
工作区 |
/v2/org/{org-name}/workspaces |
获取可访问的工作空间列表 |
工作区 |
/v2/org/{org-name}/workspaces/{id-or-name} |
获取有关工作空间的基本信息 |
工作区 |
/v2/org/{org-name}/workspaces/{id-or-name}/file/** |
从工作空间下载文件 |
作业模板 |
/v2/org/{org-name}/jobs/templates/{id} |
获取有关作业模板的信息 |
6. NGC 目录
本章介绍 Base Command Platform 的 NGC 目录功能。NGC 目录是由 NVIDIA 和合作伙伴定期发布的软件集合，可通过 Base Command Platform Web UI 和 CLI 访问。在本章中，您将学习如何识别和使用已发布的工件，将其直接用于 Base Command Platform，或作为构建和发布您自己的容器镜像和模型的基础。
NGC 提供 NVIDIA 和合作伙伴发布的、针对 NVIDIA GPU 优化的工件目录。
这些是经过精心挑选的 GPU 优化软件集。它由容器、预训练模型、用于 Kubernetes 部署的 Helm Chart 以及带有软件开发工具包 (SDK) 的行业特定 AI 工具包组成。
NGC 目录中的工件会定期更新，可用作构建 Base Command Platform 作业的自定义容器的基础。
6.1. 访问 NGC 目录
登录 NGC 网站后，单击左侧菜单中的目录 (CATALOG)，然后单击顶部 ribbon 菜单中的选项之一。
集合 (Collections)：展示深度学习和 AI 应用的集合。
容器 (Containers)：展示 NGC 容器镜像列表。
Helm Chart：展示 Helm Chart 列表。
模型 (Models)：展示预训练深度学习模型列表，这些模型可以轻松地重新训练或微调。
资源 (Resources)：提供用于创建深度学习模型的逐步说明和脚本列表。
您还可以使用过滤器栏来构建搜索过滤器和排序偏好。
6.2. 查看详细的应用信息
每张卡片显示容器名称和简短描述。
单击拉取标签 (Pull Tag) 或 获取 Helm Chart (Fetch Helm Chart) 链接（取决于工件）以将拉取或获取命令复制到剪贴板。带有下载 (Download) 链接的工件将在单击链接时下载到您的本地磁盘。
单击工件名称以打开详细信息页面。
详细信息页面的顶部显示工件的基本发布信息。
详细信息页面的底部显示有关工件的其他详细信息。
6.3. 使用 CLI
要使用 CLI 查看容器镜像列表，请发出以下命令。
$ ngc registry image list
+------+--------------+---------------+------------+--------------+------------+
| Name | Repository | Latest Tag | Image Size | Updated Date | Permission |
+------+--------------+---------------+------------+--------------+------------+
| CUDA | nvidia/cuda | 11.2.1-devel- | 2.18 GB | Feb 17, 2021 | unlocked |
| | | ubuntu20.04 | | | |
...
其他示例
要查看 PyTorch 的容器镜像列表，请发出以下命令。
$ ngc registry image list nvidia/pytorch*
+---------+----------------+------------+------------+--------------+------------+
| Name | Repository | Latest Tag | Image Size | Updated Date | Permission |
+---------+----------------+------------+------------+--------------+------------+
| PyTorch | nvidia/pytorch | 21.03-py3 | 5.89 GB | Mar 26, 2021 | unlocked |
+---------+----------------+------------+------------+--------------+------------+
要查看合作伙伴注册表空间下的容器镜像列表，请发出以下命令。
$ ngc registry image list partners/*
+-------------------+---------------------+--------------+------------+------------+----------+
| Name | Repository | Latest Tag | Image Size |Updated Date|Permission|
+-------------------+---------------------+--------------+------------+------------+----------+
| OmniSci (MapD) | partners/mapd | None | None |Sep 24, 2020| unlocked |
| H2O Driverless AI | partners/h2oai- | latest | 2 GB |Sep 24, 2020| unlocked |
| | driverless | | | | |
| PaddlePaddle | partners/paddlepadd | 0.11-alpha | 1.28 GB |Sep 24, 2020| unlocked |
| | le | | | | |
| Chainer | partners/chainer | 4.0.0b1 | 963.75 MB |Sep 24, 2020| unlocked |
| Kinetica | partners/kinetica | latest | 5.35 GB |Sep 24, 2020| unlocked |
| MATLAB | partners/matlab | r2020b | 9.15 GB |Jan 08, 2021| unlocked |
...
7. NGC 私有 Registry
本章介绍私有 Registry。作为 Base Command Platform 用户，您可以访问专为您组织分配的专用注册表空间。在本章中，您将学习如何识别您的团队或组织空间，如何与您的团队或组织共享容器镜像和模型，以及如何在 Base Command 上的工作负载中下载和使用它们。
NGC 私有 Registry 具有与 NGC 目录中相同的一组工件和功能。私有 Registry 为您提供空间，供您上传、发布自定义工件并与您的团队和组织共享，并能够根据团队和组织成员资格控制访问权限。私有 Registry 使您的组织能够拥有仅您的组织用户可以访问的专属目录。
7.1. 访问 NGC 私有 Registry
从用户 (User) 和选择团队 (Select a Team) 下拉菜单中设置您的组织和团队，然后单击左侧菜单中的 私有 Registry (Private Registry)。
单击菜单项以查看可供您的组织或团队使用的相应工件列表。
单击创建 (Create) 以打开屏幕，您可以在其中创建相应的工件并将其保存到您的组织或团队。
容器创建页面示例
模型创建页面示例
7.2. 构建和共享私有 Registry 容器镜像
本节介绍如何使用 Dockerfile 自定义来自 NGC 私有 Registry 的容器，然后将其推送到私有 Registry 中的共享注册表空间。
注意
这些说明描述了如何从您的组织和团队注册表空间中选择容器镜像，但您可以使用类似的过程来修改来自 NGC 目录的容器镜像。
选择要修改的容器镜像。
登录 NGC 网站，选择您要从中获取容器镜像的组织和团队。
单击左侧菜单中的 私有 Registry (PRIVATE REGISTRY) > 容器 (Containers)，然后单击 组织容器 (ORGANIZATION CONTAINERS) 或 团队容器 (TEAM CONTAINERS)，具体取决于您计划与谁共享您的容器镜像。
找到要拉取的容器，然后单击 拉取标签 (Pull tag) 将拉取命令复制到剪贴板。
使用复制到剪贴板的命令拉取容器镜像。
您可以使用任何方法来编辑或创建要推送到 NGC 私有 Registry 的容器，只要镜像名称遵循命名约定即可。例如，运行容器并从内部进行更改。
使用 Docker run 命令运行容器
$ docker run -it -name=pytorch nvcr.io/<org>/<team>/<container-name>:<tag> bash对容器进行任何更改（安装软件包或创建/下载文件）。
将更改提交到新镜像。
$ docker commit pytorch nvcr.io/<org>/<team>/<container-name>:<new-tag>
或者，您可以使用
Dockerfile进行更改。在安装了 Docker 的工作站上，创建一个名为
mydocker的子目录。这是一个任意目录名称。在此目录内，创建一个名为
Dockerfile的文件（大小写很重要）。这是 Docker 在创建容器时查找的默认名称。Dockerfile应类似于以下内容$ mkdir mydocker $ cd mydocker $ vi Dockerfile $ more Dockerfile # This is the base container for the new container. FROM nvcr.io/<org>/<team>/<container-name>:<tag> # Update the apt-get database RUN apt-get update # Install the package octave with apt-get RUN apt-get install -y octave $
构建 Docker 容器镜像。
$ docker build -t nvcr.io/<org>/<team>/<container-name>:<new-tag> .
注意
此命令使用默认文件
Dockerfile来创建容器。该命令以docker build开头。-t选项为此新容器创建一个标签。请注意，该标签在nvcr.io存储库中指定了组织和团队注册表空间，容器将存储在该位置。
验证 Docker 是否成功创建了镜像。
$ docker images
将镜像推送到存储库中，创建容器。
docker push nvcr.io/<org>/<team>/<container-image>:<new-tag>此时，您应登录到 NGC 容器注册表 https://ngc.nvidia.com，并在您的团队空间下查看容器是否在那里。
如果容器支持多节点
打开容器详细信息页面，单击右上角的菜单图标，然后单击 编辑详细信息 (Edit Details)。
单击 多节点容器 (Multi-node Container) 复选框。
单击菜单图标，然后单击 保存 (Save)。
如果您在团队空间中看不到容器，请确保镜像上的标签与存储库中的位置匹配。如果由于某种原因推送失败，请重试，以防您的系统与容器注册表 (nvcr.io) 之间存在通信问题。
8. NGC 密钥
NGC 密钥是一个安全的保管库/存储库，用于存储敏感信息，使您可以轻松识别外部系统或对其进行身份验证。它提供了一种可靠且直接的方法来创建、管理隐藏的环境变量并将它们添加到您的作业中。一些主要用例包括存储 API 密钥、令牌、用户名和密码以及加密密钥。
附加信息
最多可包含 64 个字符，包括字母数字字符和以下符号：
^._-+:#&一个用户最多可以拥有 100 个密钥
密钥名称
以“_”开头的名称保留用于特殊用例
以“__”开头的名称保留供系统管理员使用
密钥名称一旦创建就无法更改，需要重新创建
密钥、值和描述均限制为 256 个字符
单个密钥和值无法编辑，但可以单独删除并重新添加
8.1. 在 Web UI 中设置密钥
要在 Base Command Platform Web 应用程序中管理密钥，请单击页面右上角的用户帐户图标，然后选择 设置 (Setup)。
然后单击 查看密钥 (View Secrets) 以转到密钥页面。
在初始的 密钥 (Secrets) 页面中，单击 添加密钥 (Add Secret) 以调出 密钥详细信息 (Secret Details) 窗格。
创建密钥时，名称 (Name) 将是键值对集合的标识符，而 密钥 (Key) 将是在作业中创建的环境变量的名称。
在作业中使用密钥
在 Web UI 中创建作业时，您可以在“密钥 (Secrets)”部分中添加密钥。在其中，您可以选择包含所有键值对的整个密钥或子集。此外，将鼠标悬停在行的最右侧部分将显示覆盖密钥的选项。密钥将作为环境变量提供。
8.2. 在 CLI 中设置密钥
您可以使用 NGC CLI 执行与 Base Command Platform Web 应用程序中相同的所有操作。 ngc user secret [create|info|update|delete|list] 命令支持 CRUD 操作。
要查看可用选项和命令描述的描述，请在任何命令或选项后使用选项 -h。
示例 1：创建密钥。
$ ngc user secret create WANDB_SECRET --desc "Wandb secret" \
--pair "WANDB_API_KEY:ABC123"
示例 2：创建具有多个键值对的密钥。
$ ngc user secret create AWS_SECRET --desc "AWS secret" --pair "USERNAME:XYZ123" --pair "PASSWORD:ABC456" --pair "API_KEY:KEY_123"
您可以使用 --secret 标志将密钥添加到作业中。您可以从作业内部通过其键名作为环境变量访问它们。
示例 1：按名称添加密钥会将所有密钥添加到作业中。
$ ngc base-command run … --secret WANDB_SECRET
示例 2：要仅添加密钥中的特定键，请按如下所示指定键名。
$ ngc base-command run … --secret "GITHUB_SECRET:USERNAME"
示例 3：也可以覆盖单个密钥的键。
$ ngc base-command run … --secret "WANDB_SECRET" \
--secret "GITHUB_SECRET:USERNAME:GITHUB_USERNAME" \
--secret "GITHUB_SECRET:PASSWORD:GITHUB_PASSWORD" \
--secret "AWS_SECRET:USERNAME:AWS_USERNAME" \
--secret "AWS_SECRET:PASSWORD:AWS_PASSWORD"
9. 组织、团队和用户管理
本章适用于组织和团队管理员，并解释了组织或团队管理员可以从 NGC 网站或 CLI 执行的任务。在本章中，您将了解不同的用户角色及其在 Base Command Platform 中提供的相关范围和权限，以及用于管理用户和团队的功能。
9.1. 组织和团队概述
每个企业都分配给一个“组织 (org)”，其名称由企业在设置帐户时确定。NVIDIA Base Command Platform 为每个组织提供自己的私有注册表空间，用于运行作业，包括存储和工作空间。
可以在组织内创建一个或多个团队，以便为企业内的组提供私有访问权限。单个用户可以是组织内任意数量的团队的成员。
作为您组织的 NVIDIA Base Command Platform 管理员，您可以邀请其他用户加入您组织的 NVIDIA Base Command Platform 帐户。然后，可以将用户分配为组织内团队的成员。团队对于在组织内保持自定义工作的私密性很有用。
下表说明了组织、团队和用户之间的相互关系
组织 (ORG) |
|||
注册表空间 |
<org>/ |
||
组织管理员 (Org Admin) |
可以将用户添加到 org/ 或任何 org/team。可以创建团队。 |
||
组织用户 (Org User) |
可以访问组织内的资源和启动作业，但不能在团队内访问。 |
||
组织查看者 (Org Viewer) |
可以读取组织内的资源和作业。 |
||
团队 1 (TEAM 1) |
团队 2 (TEAM 2) |
团队 3 (TEAM 3) |
|
注册表空间 |
<org>/<team1> |
<org>/<team2> |
<org>/<team3> |
团队管理员 (Team Admin) |
可以将用户添加到 org/team1 |
可以将用户添加到 org/team2 |
可以将用户添加到 org/team3 |
团队用户 (Team User) |
可以访问和共享资源并在 org/team1 内启动作业 |
可以访问和共享资源并在 org/team2 内启动作业 |
可以访问和共享资源并在 org/team3 内启动作业 |
团队查看者 (Team Viewer) |
可以读取 org/team1 内的资源和作业 |
可以读取 org/team2 内的资源和作业 |
可以读取 org/team3 内的资源和作业 |
构建用户团队的一般工作流程如下
组织管理员邀请用户加入组织的 NVIDIA Base Command 帐户。
组织管理员在组织内创建团队。
组织管理员将用户添加到相应的团队，并且通常至少分配一个用户作为团队管理员。
组织或团队管理员随后可以将其他用户添加到团队。
9.2. NVIDIA Base Command Platform 用户角色
在添加用户和团队之前，请先熟悉以下每个角色的描述。
9.2.1. Base Command 管理员
Base Command 管理员 (BASE_COMMAND_ADMIN) 是分配给企业 Base Command Platform 组织管理员的角色。
以下是组织管理员的功能摘要
访问所有读写和适当的共享命令，这些命令涉及以下功能
组织内的作业、工作空间、数据集和结果。
团队管理员具有与组织管理员相同的功能，但有以下限制
功能仅限于特定团队。
9.2.2. Base Command 用户角色
Base Command 用户角色 (BASE_COMMAND_USER) 可以使用所有 NVIDIA Base Command Platform 任务。这包括对用户的组织或团队内的作业、工作空间、数据集和结果的所有读取、写入和适当的共享功能。
9.2.3. Base Command 查看者角色
Base Command 查看者用户 (BASE_COMMAND_VIEWER) 具有与 Base Command 用户相同的范围，但对角色范围（组织或团队）内的所有作业、工作空间、数据集和结果具有只读访问权限。
9.2.4. Registry 管理员角色
Registry 管理员 (REGISTRY_USER_ADMIN) 是分配给企业的初始组织管理员的角色。
以下是 Registry 管理员组织管理员的功能摘要
访问所有读写和适当的共享命令，这些命令涉及以下功能
组织内的容器、模型和资源
团队管理员具有与组织管理员相同的功能，但有以下限制
功能仅限于特定团队。
团队管理员无法创建其他团队或删除团队
9.2.5. Registry 读取角色
Registry 读取 (REGISTRY_READ) 角色对用户的组织或团队内的容器、模型和资源具有只读访问权限。
9.2.6. Registry 用户角色
Registry 用户 (REGISTRY_USER_USER) 可以充分利用所有私有 Registry 功能。这包括对用户的组织或团队内的容器、模型和资源的所有读取、写入和适当的共享功能。
9.2.7. 用户管理员角色
用户管理员 (USER_ADMIN) 用户管理组织或团队内的用户。组织的 User Admin 可以在该组织内创建团队。
9.2.8. 用户读取角色
用户读取 (USER_READ) 用户可以查看组织或团队内的详细信息。
9.3. 分配角色
每个角色都针对特定功能。分配角色时，请记住您希望用户或管理员实现的所有功能。大多数用户和管理员都需要分配多个角色。使用下表作为指导
9.3.1. 分配管理员角色
请参阅下表，了解每个管理员角色功能的摘要。您可能需要分配多个角色，具体取决于您希望管理员拥有的功能。
角色 |
用户或团队 |
作业、工作空间、数据集、结果 |
容器、模型、资源 |
|---|---|---|---|
Base Command 管理员 |
不适用 |
读/写 |
不适用 |
Base Command 查看者 |
不适用 |
只读 |
不适用 |
注册表管理员 |
不适用 |
不适用 |
读/写 |
用户管理员 |
读/写 |
不适用 |
不适用 |
示例：要为用户管理、Registry 管理和作业管理添加管理员，请发出以下命令
$ ngc org add-user <email> <name> --role USER_ADMIN --role REGISTRY_USER_ADMIN --role BASE_COMMAND_ADMIN
9.3.2. 分配用户角色
请参阅下表，了解每个用户角色功能的摘要。您可能需要分配多个角色，具体取决于您希望用户拥有的功能。
角色 |
用户 |
作业、工作空间、数据集、结果 |
容器、模型、资源 |
|---|---|---|---|
Base Command 用户 |
不适用 |
读/写 |
不适用 |
注册表读取 |
不适用 |
不适用 |
只读 |
注册表用户 |
不适用 |
不适用 |
读/写 |
示例：要添加可以使用自定义容器运行作业的用户，请发出以下命令
$ ngc org add-user <email> <name> --role BASE_COMMAND_USER --role REGISTRY_USER
9.4. 组织和团队管理员任务
对于组织或团队管理员，最有可能需要的命令是添加用户。以下是使用 CLI 添加用户的典型过程。
将用户添加到组织
$ ngc org add-user <email> <name> --role <user-role>
创建团队
$ ngc org add-team <name> <description>
将用户添加到团队（如果他们还不是成员，则添加到组织）
$ ngc team add-user --team <team> <email> <name> --role <user-role>
可以使用以下命令查找列出用户、添加其他管理员的其他命令
ngc org --help
或
ngc team --help
或在 CLI 文档中查找。
9.4.1. 管理团队
您可以使用 Web 界面创建和删除团队。
9.4.1.1. 使用 Web UI 创建团队
创建团队对于允许用户在团队内共享镜像，同时对同一组织中的其他团队保持不可见非常有用。只有组织管理员才能创建团队。
要创建团队，请执行以下操作
登录到 NGC 网站。
从左侧导航菜单中选择 组织 (Organization) > 团队 (Teams)。
单击页面右上角的 创建团队 (Create Team) 菜单。
在 创建团队 (Create Team) 对话框中，输入团队名称和描述，然后单击 创建团队 (Create Team)。
9.4.1.2. 使用 Web UI 删除团队
删除团队将撤销对团队内共享资源的访问权限。任何未与团队关联的资源将保持不受影响。只有组织管理员才能删除团队。
要删除团队，请执行以下操作
登录到 NGC 网站。
从左侧导航菜单中选择 组织 (Organization) > 团队 (Teams)。
从列表中，选择您要删除的团队以转到其页面。
单击右上角的垂直省略号，然后选择 删除团队 (Delete Team)。
确认您的选择。
9.4.2. 管理用户
您可以使用 Web 界面创建和删除用户。
9.4.2.1. 使用 Web UI 创建用户
作为组织管理员，您必须创建用户帐户，以允许其他人在组织内使用 NVIDIA Base Command Platform。
登录到 NGC 网站。
从左侧导航菜单中单击组织 > 用户。
单击页面右上角的邀请新用户。
在新页面上，填写用户信息部分。为名字输入您的屏幕名称，并输入接收邀请电子邮件的电子邮件地址。
在角色部分中，选择适当的上下文（组织或特定团队）以及下面框中显示的可用角色。单击右侧的添加角色以保存您的更改。您可以在创建用户之前添加或删除多个角色。
添加角色后，仔细检查所有字段，然后单击右上角的创建用户。邀请电子邮件将自动发送给用户。
9.4.2.2. 使用 Web UI 删除用户
如果用户离开公司，组织管理员可能需要删除该用户。
删除用户将禁用任何共享资源，并撤销所有团队成员对用户共享的工作空间和数据集的访问权限。
要删除用户，请执行以下操作
登录到 NGC 网站。
单击左侧导航菜单中的 组织 (Organization) > 用户 (Users)。
从列表中，选择您要删除的用户以转到其页面。
单击页面右上角的 删除用户 (Remove User)。
确认您的选择。
10. NVIDIA Base Command Platform 数据概念
本章介绍 NVIDIA Base Command Platform 中可用的存储数据实体。在本章中，您将了解数据集、工作空间、结果以及计算实例本地的存储空间及其用例。您将了解可以从计算实例内以及从您的工作站（通过 Web UI 和 CLI）对这些数据存储实体执行的操作。
10.1. 数据类型
NVIDIA Base Command Platform 在 ACE 内的网络存储上具有以下数据类型
数据集 (Dataset)：可共享的只读工件，可挂载到作业。数据在作业完成后仍然存在，并且对于每个副本都是相同的。
工作空间 (Workspace)：可共享的读写工件，可挂载到作业。数据在作业完成后仍然存在，并且对于每个副本都是相同的。
结果 (Result)：作业私有的读写工件，为作业中的每个副本自动生成。数据在作业完成后仍然存在，并且对于每个副本都是唯一的。
提示
如果多副本作业的自定义结果数据需要跨所有副本相同的共享存储，请为此目的使用工作空间。
本地暂存空间 (Local scratch space)：副本私有的读写本地暂存空间。数据在作业完成后不会持久存在，并且对于每个副本都是唯一的。
密钥 (Secrets)：用于第三方身份验证的加密令牌和密码。数据在作业完成后仍然存在，并且对于每个副本都是相同的。
重要提示
除了本地暂存空间外，容器内的所有其他存储路径在作业完成后都不会持久保存新数据或扩充数据。
例如，如果用户在作业中将数据写入 /mnt/，并且 /mnt 未用作工作空间或结果的路径，则写入的数据将不会出现在未来的作业运行中，即使该作业是先前作业的精确克隆。
10.2. 管理数据集
数据集旨在用于生产工作负载的只读数据，这些数据具有可重复性、出处和可扩展性。它们可以与您的团队或整个组织共享。
10.2.1. 按组织或团队确定数据集
要使用 NGC 网站查看数据集列表，请单击左侧菜单中的“数据集”，然后从 ribbon 菜单中选择一个选项卡，具体取决于您是要查看对您可用的所有数据集、仅对您的组织可用的数据集，还是仅对您的团队可用的数据集。
10.2.2. 在作业中挂载数据集
数据集是深度学习训练作业的关键组成部分。它们旨在作为高性能、可共享的只读数据，适用于具有可重复性和可扩展性的生产工作负载。可以将多个数据集挂载到同一作业。多个作业和用户可以同时挂载一个数据集。
要挂载一个或多个数据集，请在创建新作业时从 NGC 作业创建页面指定数据集和挂载点。
从“数据输入”部分，选择“数据集”选项卡，然后使用可用的搜索条件搜索要挂载的数据集。
从列表中选择一个或多个数据集。
为每个选定的数据集指定唯一的挂载点。
10.2.3. 使用 Web UI 下载数据集
要使用 NGC 网站下载数据集，请从列表中选择一个数据集以打开所选数据集的详细信息页面。
单击文件浏览器选项卡，然后选择要下载的文件之一。
该文件将下载到您的“下载”文件夹。
10.2.4. 使用 NGC CLI 管理数据集
10.2.4.1. 上传和共享数据集
创建、上传和可选共享数据集在一个步骤中完成
$ ngc dataset upload --source <dir> --desc "my data" <dataset_name> [--share <team_name>]
示例:
$ ngc dataset upload --source mydata/ --desc "mnist is great" mnist --share my_team1
要与多个团队共享，请使用多个 --share 参数。
示例:
$ ngc dataset upload --source mydata/ --desc "mnist is great" mnist --share my_team1 --share my_team2
提示
虽然 --share 参数是可选的，但在上传数据集时使用 --share 参数是一种确保您的数据集被共享的便捷方式，这样您就不必记住稍后共享它们。
重要提示
永远不要重复使用数据集的名称，因为您的组织将失去重复和验证实验的能力。
10.2.4.3. 列出数据集
列出可用的现有数据集
$ ngc dataset list
这会列出配置的组织和团队可用的所有数据集。
示例输出
$ ngc dataset list
+-------------+------------+-------------+-------------+------------+--------+-----------+-----------+------------+-------+---------+
| Id | Integer Id | Name | Description | ACE | Shared | Size | Status | Created | Owned | Pre-pop |
| | | | | | | | | Date | | |
+-------------+------------+-------------+-------------+------------+--------+-----------+-----------+------------+-------+---------+
| Qo-D942jRZ6 | 91107 | BraTS21 | | nv- | Yes | 14.69 GB | COMPLETED | 2021-11-11 | No | No |
| qMTM2MMOrvQ | | | | eagledemo- | | | | 00:19:22 | | |
| | | | | ace | | | | UTC | | |
使用 -h 选项用于 list 命令，以显示所有基于上下文的选项，包括 --owned，这对于仅列出用户拥有的数据集非常有用。
列出您拥有的数据集
$ ngc dataset list --owned
列出团队内的数据集
$ ngc dataset list --team <teamname>
10.2.4.4. 下载数据集
要下载数据集，请从 NGC 网站确定数据集 ID，然后发出以下命令将数据集下载到当前文件夹。
$ ngc dataset download <datasetid>
要下载到特定的现有文件夹，请在命令中指定路径。
$ ngc dataset download <datasetid> --dest <destpath>
10.2.4.5. 删除数据集
要从 ACE 上的 NGC 删除数据集
$ ngc dataset remove <datasetid>
10.2.5. 导入和导出数据集
可以使用 NGC CLI 从 S3（对象存储）导入和导出数据集，包括预身份验证的 URL（目前仅在 OCI 上）。为此，您必须设置具有特定密钥的 Secrets。
10.2.5.1. 先决条件
NGC CLI 版本 >= 3.2x.0
拥有一个名为 “ngc” 且密钥为 “ngc_api_key” 的 secret
$ ngc user secret create ngc --pair ngc_api_key:<your NGC API key>
对于 S3 实例
注意：以下示例适用于 AWS，但任何 S3 兼容实例都将有效。
一个具有密钥的 secret：“aws_access_key_id”、“aws_secret_access_key”
$ ngc user secret create my_aws_secret \ --pair aws_access_key_id:<AWS_ACCESS_KEY_ID> \ --pair aws_secret_access_key:<AWS_SECRET_ACCESS_KEY>
对于预身份验证的 URL（目前在 OCI 上）
一个密钥名为 “oci_preauth_url” 的 secret
$ ngc user secret create my_oci_secret \ --pair oci_preauth_url:<Authenticated URL from OCI>
10.2.5.2. 导入数据集
您可以使用以下命令导入数据集。
$ ngc dataset import start --protocol s3 --secret my_aws_secret --instance <instance type> --endpoint https://s3.amazonaws.com --bucket <s3 bucket name> --region <region of bucket>
----------------------------------------------------------------
Dataset Import Job Details
Id: 1386055
Source: s3:https://s3.amazonaws.com/<s3 bucket name>/
Destination: resultset 1386055
Status: QUEUED
Start time: 2023-04-19 04:29:36 UTC
Finish time:
Directories found: 1
Directories traversed: 0
Files found: 0
Files copied: 0
Files skipped: 0
Total bytes copied: 0
----------------------------------------------------------------
这将启动一个具有相同 ID 的作业，该作业会将 bucket 的内容下载到该作业的结果文件夹中。
当使用 OCI 实例时，由于 secret 已经包含该信息，因此不需要指定源/目标 URL。因此，命令将如下所示
$ ngc dataset import start --protocol url --secret my_oci_secret --instance <instance type> <dataset id>
要检查提交作业的状态，请运行以下命令
$ ngc dataset import info <job_id>
作业状态将从 QUEUED > RUNNING > FINISHED_SUCCESS 变为 FAILED（如果遇到任何不可恢复的错误）。
要快速检查所有导入作业，请使用
$ ngc dataset import list
一旦作业的状态为 FINISHED_SUCCESS，请使用下一个命令将该作业的结果转换为新的数据集
$ ngc dataset import finish <job_id> --name <dataset_name> --desc <dataset_description>
或者，复制同一 ACE 上另一个数据集的名称、描述和共享权限
$ ngc dataset import finish <job_id> --from-dataset <dataset_id>
10.2.5.3. 导出数据集
您可以使用以下命令导出数据集。
$ ngc dataset export run --protocol s3 --secret my_aws_secret --instance <instance type> --endpoint https://s3.amazonaws.com/ --bucket <s3 bucket name> --region <region of bucket> <dataset_id>
----------------------------------------------------------------
Dataset Export Job Details
Id: 1386056
Source: dataset 515151
Destination: s3:https://s3.amazonaws.com/<s3 bucket name>/
Status: QUEUED
Start time: 2023-04-20 04:23:31 UTC
Finish time:
Directories found: 1
Directories traversed: 0
Files found: 0
Files copied: 0
Files skipped: 0
Total bytes copied: 0
----------------------------------------------------------------
这将启动一个作业，该作业将数据集的内容复制到目标对象存储。
当使用 OCI 实例时，由于 secret 已经包含该信息，因此不需要指定源/目标 URL。因此，命令将如下所示
$ ngc dataset export run --protocol url --secret my_oci_secret --instance <instance type> <dataset id>
与导入数据集一样，可以使用以下命令监控导出作业
$ ngc dataset import list
以及有关单个导入作业的详细信息
$ ngc dataset import info <job_id>
10.2.5.4. 从外部源构建数据集
许多深度学习训练作业使用来自互联网的公共可用数据集，这些数据集已获得特定用例的许可。如果您需要使用此类数据集，并且它们与上述数据集导入命令不兼容，NVIDIA 建议将数据集克隆到 BCP 存储中，以避免在每次运行时重复从外部源下载文件。
要仅使用 BCP 资源构建数据集
在 CPU 或 1-GPU 实例上运行交互式作业。
执行命令以下载和预处理您的文件，并将它们放在 Result 挂载中。
完成作业并使用 使用 CLI 将 /result 转换为数据集 将来自 Result 的已处理文件转换为新的数据集。
10.2.6. 将检查点转换为数据集
对于某些工作流程，例如用于迁移学习工具包 (TLT)，您可能需要保存检查点的时间比当前项目的时间长。然后可以将这些检查点与您的团队共享。
NVIDIA Base Command Platform 允许您将训练作业的检查点另存为数据集，以便长期存储并与团队共享。根据作业配置，检查点从作业 /results 挂载或作业 workspace 挂载中获取。
10.2.6.1. 使用 NGC Web UI 将 /result 转换为数据集
注意
此操作将删除 /result 目录中的原始文件以创建数据集，并且无法撤消。
您可以从 NGC Web UI 将 /result 转换为数据集。
从Base Command > 仪表板或 Base Command > 作业页面，单击包含要转换的 /result 文件的作业的菜单图标，然后选择转换结果。
在“将结果转换为数据集”对话框中，输入名称和（可选）描述。
完成后，单击转换。数据集已创建，您可以从 Base Command > 数据集页面查看。
10.2.6.2. 使用 CLI 将 /result 转换为数据集
注意
此操作将删除 /result 目录中的原始文件以创建数据集，并且无法撤消。
您可以使用 NGC Base Command Platform CLI 将 /result 转换为数据集，如下所示
$ ngc dataset convert <new-dataset-name> --from-result <job-id>
10.2.6.3. 从 Workspace 保存检查点
要从您的 workspace 保存检查点，请下载 workspace，然后按如下方式上传为数据集
将 workspace 下载到您的本地磁盘。
$ ngc workspace download <workspace-id> --dest <download-path>
您还可以在 workspace 中指定路径，仅下载必要的文件。
$ ngc workspace download --dir path/within/workspace <workspace-id> --dest <download-path>
使用
-h选项查看用于指定 workspace 中要下载的文件夹和文件的选项。下载的内容将放置在标记为 <workspace-id> 的文件夹中。将文件上传到一个数据集。
$ ngc dataset upload <dataset-name> --source <path-to-files>
文件将上传到设置的 ACE。
10.3. 管理 Workspace
Workspace 是可共享的读写持久存储，可以在作业中挂载以供并发使用。它们旨在作为读写卷的工具，在作业或用户之间提供临时空间。它们有一个 ID 并且可以命名。它们计入您的总存储配额。
workspace 的主要用例是在作业之间共享持久数据；例如，用于检查点或重新训练。
workspace 还为团队中的用户提供了一种在共享存储空间中协同工作的简便方法。Workspace 是存储代码的好地方，可以轻松地与 git 同步，甚至可以在作业运行时更新，尤其是交互式作业。这意味着您可以在交互模式下快速进行实验，而无需为每次代码更改上传新的容器或数据集。
10.3.1. Workspace 限制
没有可重复性或其他生产工作流程保证、审计、出处等。
读/写竞争条件，具有未定义的写入顺序。
文件锁定行为未定义。
带宽和 IOPS 性能受到限制，就像任何共享文件系统一样。
10.3.2. Workspace 用例示例
多个作业可以写入一个 workspace，并使用 TensorBoard 进行监控。
用户可以将 Workspace 用作网络主目录。
团队可以将 Workspace 用作共享存储区域。
代码可以放在 Workspace 中而不是容器中，同时在实验期间仍在迭代并被多个作业使用（请参阅上面的危险）
10.3.3. 从 Web UI 挂载 Workspace
Workspace 为任何用例提供了简单的解决方案。
要挂载一个或多个 workspace，请在创建新作业时从 NGC 作业创建页面指定 workspace 和挂载点。
从“数据输入”部分，选择“Workspace”选项卡，然后使用可用的搜索条件搜索要挂载的 workspace。
从列表中选择一个或多个 workspace。
为每个选定的 workspace 指定唯一的挂载点。
10.3.4. 创建 Workspace
10.3.4.1. 使用 Web UI 创建 Workspace
从左侧导航菜单中选择 Base Command > Workspace，然后单击页面右上角的 创建 Workspace 菜单。
在 创建 Workspace 对话框中，输入 workspace 名称并选择要与 workspace 关联的 ACE。
单击 创建。
workspace 将添加到 workspace 列表。
10.3.4.2. 使用 Base Command Platform CLI 创建 Workspace
创建 workspace 涉及一个命令，该命令输出生成的 Workspace ID
$ ngc workspace create --name <workspace-name>
Workspace 可以命名以便于参考。它只能命名一次，即 workspace 无法重命名。您可以在创建 workspace 时命名，也可以在之后命名。
10.3.4.3. 使用唯一的 Workspace 名称
由于 workspace 可以通过名称和 ID 指定，因此必须确保这些名称和 ID 都是唯一的。Workspace ID 由系统生成，而名称由用户指定。Workspace ID 始终为 22 个字符长。为了确保用户指定的名称与未来的 workspace ID 不匹配，不允许使用正好 22 个字符的 workspace 名称。
Workspace 名称必须遵循以下约束
名称不能为 22 个字符长。
名称必须以字母数字字符开头。
名称可以包含字母数字字符、- 或 _ 字符。
名称在组织内必须是唯一的。
这些限制也捕获在正则表达式 ^(?![-_])(?![a-zA-Z0-9_-]{22}$)[a-zA-Z0-9_-]*$ 中。
10.3.4.4. 在创建 Workspace 时命名
$ ngc workspace create --name ws-demo
Successfully created workspace with id: XB1Cym98QWmsX79wf0n3Lw
Workspace Information
ID: XB1Cym98QWmsX79wf0n3Lw
Name: ws-demo
Created By: John Smith
Size: 0 B
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: None
10.3.4.5. 在创建 Workspace 后命名
创建未命名 workspace 的示例。
$ ngc workspace create
Successfully created workspace with id: s67Bcb_GQU6g75XOglOn8g
如果您创建了一个未命名的 workspace，您可以稍后通过指定 ID 并使用 set -n <name> 选项来命名它。
$ ngc workspace set -n ws-demo s67Bcb_GQU6g75XOglOn8g -y
Workspace name for workspace with id s67Bcb_GQU6g75XOglOn8g has been set.
$ ngc workspace info ws-demo
----------------------------------------------------
Workspace Information
ID: s67Bcb_GQU6g75XOglOn8g
Name: ws-demo
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: None
---------------------------------------------------
10.3.5. 列出 Workspace
您可以列出您有权访问的 workspace，并获取特定 workspace 的详细信息
$ ngc workspace list
+-----------------+------------+--------------+--------------+----------------+---
| Id | Name | Description | ACE | Creator |
| | | | | Username |
+-----------------+------------+--------------+--------------+----------------+---
| s67Bcb_GQU6g75X | ws-demo | | nv-us-west-2 | Sabu Nadarajan |
| OglOn8g | | | | |
|-----------------+------------+--------------+--------------+----------------+---
$ ngc workspace info ws-demo
----------------------------------------------------
Workspace Information
ID: s67Bcb_GQU6g75XOglOn8g
Name: ws-demo
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: None
----------------------------------------------------
10.3.6. 在作业中使用 Workspace
注意
大多数 NVIDIA DL 镜像已经有一个包含 NVIDIA 示例的目录 /workspace。当在作业定义中指定 workspace 的挂载点时，请注意它不会与容器中的现有目录冲突。使用容器中不存在的唯一目录名称。在下面的示例中，workspace 的名称用作挂载点。
通过在命令行中指定挂载点来运行作业，workspace 的访问权限在作业中可用。
$ ngc base-command run -i nvidia/tensorflow:18.10-py3 -in dgx1v.16g.1.norm --ace
nv-us-west-2 -n HowTo-workspace --result /result --commandline 'sleep
5h'
----------------------------------------------------
Job Information
Id: 223282
Name: HowTo-workspace
...
Datasets, Workspaces and Results
Dataset ID: 8181
Dataset Mount Point: /dataset
Workspace ID: s67Bcb_GQU6g75XOglOn8g
Workspace Mount Point: /ws-demo
Workspace Mount Mode: RW
Result Mount Point: /result
...
----------------------------------------------------
Workspace 默认以读写 (RW) 模式挂载。也支持以只读 (RO) 模式挂载。在 RO 模式下，它的功能类似于 dataset。
$ ngc base-command run -i nvidia/tensorflow:18.10-py3 -in dgx1v.16g.1.norm --ace
nv-us-west-2 -n HowTo-workspace --result /result --commandline 'sleep 5h'
--datasetid 8181:/dataset --workspace ws-demo:/ws-demo:RO
----------------------------------------------------
Job Information
Id: 223283
Name: HowTo-workspace
...
Datasets, Workspaces and Results
Dataset ID: 8181
Dataset Mount Point: /dataset
Workspace ID: s67Bcb_GQU6g75XOglOn8g
Workspace Mount Point: /ws-demo
Workspace Mount Mode: RO
Result Mount Point: /result
...
----------------------------------------------------
下面显示了在作业中使用 JSON 文件指定 workspace。下面的示例来自本节中显示的第一个作业定义。
{
"aceId": 357,
"aceInstance": "dgxa100.40g.1.norm",
"aceName": "nv-eagledemo-ace",
"command": "sleep 5h",
"datasetMounts": [
{
"containerMountPoint": "/dataset",
"id": 8181
}
],
"dockerImageName": "nvidia/tensorflow:18.10-py3",
"name": "HowTo-workspace",
"resultContainerMountPoint": "/result",
"runPolicy": {
"preemptClass": "RUNONCE"
},
"workspaceMounts": [
{
{
"containerMountPoint": "/ws-demo",
"id": "ws-demo",
"mountMode": "RW"
}
]
}
10.3.7. 使用 SFTP 访问 Workspace
安全文件传输协议 (SFTP) 是一种常用的网络协议，用于安全地访问和传输往返于网络可访问存储的数据。Base Command Platform Workspace 与 SFTP 兼容工具互操作，以提供对 BCP 环境中存储的标准且安全的访问方法。
NGC CLI 可用于查询 workspace 并公开要与 SFTP 客户端一起使用的端口、主机名和令牌。运行带有 --show-sftp 标志的 ngc base-command workspace info 将返回通过 SFTP 与 workspace 通信所需的所有信息，以及用于使用 sftp CLI 工具的示例命令。
$ ngc base-command workspace info X7xHfMZISZOfUbKKtGnMng --show-sftp
-------------------------------------------------------------------------------
Workspace Information
ID: X7xHfMZISZOfUbKKtGnMng
Name: sftp-test
Created By: user@company.com
Size: 0 B
ACE: example-ace
Org: nvidia
Description: My workspace for using SFTP to move data
Shared with:
-------------------------------------------------------------------------------
SFTP Information
Hostname: example-ace.dss.stg-ace.ngc.nvidia.com
Port: 443
Token: ABCDEFGHIJBObk5sWVhBemNXZzBOM05tY2pkMFptSTNiRzFsWVhVME9qQmpOamMzTWpFNExUaGlZVEV0TkRkbU1pMDVZakUzTFdZME9USTVORGN4TVRnMk5BLCwsWDd4SGZNWklTWk9mVWJLS3RHbk1uZywsLG52aWRpYQ==
Example: sftp -P<Port> <Token>@<Hostname>:/
-------------------------------------------------------------------------------
10.3.7.1. 使用 SFTP 工具连接到 Workspace
Linux、WSL 和 MacOS shells 可用的 sftp 工具可以与上面 NGC CLI 输出中提供的示例一起使用。以下是使用 sftp 和先前示例的输出。
sftp -P443 ABCDEFGHIJBObk5sWVhBemNXZzBOM05tY2pkMFptSTNiRzFsWVhVME9qQmpOamMzTWpFNExUaGlZVEV0TkRkbU1pMDVZakUzTFdZME9USTVORGN4TVRnMk5BLCwsWDd4SGZNWklTWk9mVWJLS3RHbk1uZywsLG52aWRpYQ==@example-ace.dss.stg-ace.ngc.nvidia.com:/
Connected to example-ace.dss.stg-ace.ngc.nvidia.com.
Changing to: /
sftp>
可以通过在提示符下输入 ? 来查看 sftp 支持的命令
sftp> ?
Available commands:
bye Quit sftp
cd path Change remote directory to 'path'
chgrp grp path Change group of file 'path' to 'grp'
chmod mode path Change permissions of file 'path' to 'mode'
chown own path Change owner of file 'path' to 'own'
df [-hi] [path] Display statistics for current directory or
filesystem containing 'path'
exit Quit sftp
get [-afPpRr] remote [local] Download file
reget [-fPpRr] remote [local] Resume download file
reput [-fPpRr] [local] remote Resume upload file
help Display this help text
lcd path Change local directory to 'path'
lls [ls-options [path]] Display local directory listing
lmkdir path Create local directory
ln [-s] oldpath newpath Link remote file (-s for symlink)
lpwd Print local working directory
ls [-1afhlnrSt] [path] Display remote directory listing
lumask umask Set local umask to 'umask'
mkdir path Create remote directory
progress Toggle display of progress meter
put [-afPpRr] local [remote] Upload file
pwd Display remote working directory
quit Quit sftp
rename oldpath newpath Rename remote file
rm path Delete remote file
rmdir path Remove remote directory
symlink oldpath newpath Symlink remote file
version Show SFTP version
!command Execute 'command' in local shell
! Escape to local shell
? Synonym for help
以下是使用 put 命令的示例。
sftp> put large-file
Uploading large-file to /large-file
large-file 16% 2885MB 21.9MB/s 11:07 ETA
完成使用 sftp 后，使用 bye、quit 或 exit 命令结束活动会话
sftp> bye
10.3.7.2. 使用 WinSCP 连接到 Workspace
WinSCP 是一款常用的 SFTP 应用程序，用于 Windows 操作系统中的 SFTP 文件传输。一旦将 WinSCP 下载并安装到用户的工作站，就可以将与 sftp CLI 工具相同的数据填充到 WinSCP 用户界面中。将文件协议切换到 SFTP，并填充主机名和端口号。不要填充用户名或密码。单击 登录 以继续。
用户界面将提示输入用户名值 - 粘贴来自 workspace 的 NGC CLI 输出的令牌，然后单击“确定”。
本地文件系统和 workspace 内容现在将并排可见。用户现在可以在两个文件系统之间根据需要拖放文件。
10.3.8. Workspace 的批量文件传输
10.3.8.1. 上传和下载 Workspace
挂载 workspace 以访问或传输少量文件效果很好。如果您需要批量传输许多文件，例如在开始时填充空 workspace 或下载整个 workspace 以进行存档，则 workspace upload 和 download 命令效果更好。
将目录上传到 workspace 类似于将文件上传到数据集。
$ ngc workspace upload --source ngc140
s67Bcb_GQU6g75XOglOn8g
Total number of files is 6459.
Uploaded 170.5 MB, 6459/6459 files in 9s, Avg Upload speed: 18.82 MB/s, Curr
Upload Speed: 25.9 KB/s
----------------------------------------------------
Workspace: s67Bcb_GQU6g75XOglOn8g Upload: Completed.
Imported local path (workspace): /home/ngccli/ngc140
Files transferred: 6459
Total Bytes transferred: 178777265 B
Started at: 2018-11-17 18:26:33.399256
Completed at: 2018-11-17 18:26:43.148319/
Duration taken: 9.749063 seconds
----------------------------------------------------
将 workspace 下载到本地目录类似于从作业下载结果。
$ ngc workspace download --dest temp s67Bcb_GQU6g75XOglOn8g
Downloaded 56.68 MB in 41s, Download speed: 1.38 MB/s
----------------------------------------------------
Transfer id: s67Bcb_GQU6g75XOglOn8g Download status: Completed.
Downloaded local path: /home/ngccli/temp/s67Bcb_GQU6g75XOglOn8g
Total files downloaded: 6459
Total downloaded size: 56.68 MB
Started at: 2018-11-17 18:31:03.530342
Completed at: 2018-11-17 18:31:45.592230
Duration taken: 42s seconds
----------------------------------------------------
10.3.8.2. 导出 Workspace
Workspace 也可以直接导出到 S3 和 OCI 实例。有关导出数据集的先决条件的详细信息，请参阅 导入和导出数据集。
以下命令会将给定 workspace 中的所有文件导出到 AWS 中的 s3 bucket
$ ngc workspace export run --protocol s3 --secret my_aws_secret \
--instance <instance type> --endpoint https://s3.amazonaws.com \
--bucket <s3 bucket name> --region <region of bucket> <workspace_id>
要将 workspace 导出到 OCI 存储实例，请使用以下参数
$ ngc workspace export run --protocol url --secret my_oci_secret --instance <instance type> <workspace_id>
与导出数据集类似，您可以使用以下命令检查导出作业的状态
$ ngc workspace export info <job_id>
或使用以下命令检查所有过去和当前的 workspace 导出作业
$ ngc workspace export list
10.3.9. Workspace 共享和撤销共享
Workspace 可以与团队或整个组织共享。
重要提示
每个 workspace 对于创建它的用户都是私有的，直到您决定与您的团队共享。一旦您与您的团队共享，所有团队成员在该 workspace 中都具有相同的权限，因此在共享之前制定共享协议。例如，使用 workspace 的一种方式是拥有一个公共区域，只有所有者更新，以及多个用户目录，每个用户一个，每个用户可以在其中写入自己的数据。
与团队共享 workspace
$ ngc workspace info ws-demo
----------------------------------------------------
Workspace Information
ID: s67Bcb_GQU6g75XOglOn8g
Name: ws-demo
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: None
----------------------------------------------------
$ ngc workspace share --team nves -y ws-demo
Workspace successfully shared
$ ngc workspace info ws-demo
----------------------------------------------------
Workspace Information
ID: s67Bcb_GQU6g75XOglOn8g
Name: ws-demo
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: nvidian/nves
----------------------------------------------------
撤销共享 workspace
$ ngc workspace revoke-share --team nves -y ws-demo
Workspace share successfully revoked
$ ngc workspace info ws-demo
----------------------------------------------------
Workspace Information
ID: s67Bcb_GQU6g75XOglOn8g
Name: ws-demo
ACE: nv-us-west-2
Org: nvidian
Description:
Shared with: None
----------------------------------------------------
10.3.10. 删除 Workspace
10.3.10.1. 使用 Web UI
您可以使用 Web UI 删除未共享的 workspace
从左侧导航菜单中选择 Base Command > Workspace，然后从列表中单击一个 workspace。
单击页面右上角的垂直省略号菜单，然后选择 删除 Workspace。
共享的 workspace 无法使用 Web UI 删除。以下示例显示，对于与 nv-test 团队共享的 workspace，删除 Workspace 命令已禁用。
10.3.10.2. 使用 CLI
删除未共享的 workspace 涉及一个命令
$ ngc workspace remove ws-demo
Are you sure you would like to remove the workspace with ID or name: 'ws-demo' from org: '<org_name>'? [y/n]y
Successfully removed workspace with ID or name: 'ws-demo' from org: '<org_name>'.
共享的 workspace 无法使用 CLI 删除。如果您尝试删除共享的 workspace，您将看到以下消息
$ ngc workspace remove test-shared-workspace
Are you sure you would like to remove the workspace with ID or name: 'test-shared-workspace' from org: '<org_name>'? [y/n]y
Removing of workspace with ID or name: 'test-shared-workspace' failed: Client Error: 422
Response: Workspace '<workspace_id>' can't be deleted while it is shared.
It is shared with: <org_name/team_name> - Request Id: None. Url: <workspace_url>.
10.4. 管理结果
作业结果由 joblog.log 文件和写入结果挂载的所有其他文件组成。在多节点作业的情况下，每个节点都分配有一个唯一的结果挂载和 joblog.log 文件。因此，结果挂载不适合跨节点同步。
10.4.1. joblog.log
对于使用 array-type “MPI” 运行的作业，STDOUT 和 STDERR 的输出将合并到结果目录中的 joblog.log 文件中。在多节点作业的情况下，默认行为是将来自所有节点的 STDOUT 和 STDERR 输出流式传输到第一个节点（副本 0）上的 joblog.log 文件。因此，其他节点上的其余日志文件将为空。
对于使用 array-type “PYTORCH” 运行的作业，STDOUT 和 STDERR 的输出将写入作业结果目录中单独的每个节点、每个 rank 的文件中。例如，node 0 rank 0 的 STDOUT 和 STDERR 将分别写入 /result/node_0_local_rank_0_stdout、/result/node_0_local_rank_0_stderr。然后，每个工作节点的 joblog.log 将包含以下格式的聚合日志，其中包含来自每个节点、每个 rank 文件的日志内容
{"date":"DATE_TIMESTAMP","file":"FILE_NAME","log":"LOG_FROM_FILE"}
这些作业日志可以在 NGC Web UI 中查看。有关如何操作的说明，请参阅 监控控制台日志 (joblog.log)。
10.4.2. 下载结果
要下载作业的结果，请使用以下命令
$ ngc result download <job-id>
对于多节点作业，此命令将检索第一个节点/副本的结果。要获取其他节点的结果，您需要按如下方式指定副本 ID
$ ngc result download <job-id>:<replica-id>
内容将下载到名为 <job-id > 的文件夹。在多节点作业的情况下，如果指定了副本 ID，则文件夹将命名为 <job-id >_<replica-id >。
10.4.3. 删除结果
结果将继续占用系统配额，直到您删除它们。要删除结果，请使用以下命令
$ ngc result remove <job-id>
10.4.4. 将结果转换为数据集
如果您希望将结果转换为数据集，请按照以下步骤操作
从左侧导航栏中选择 作业。
找到您要从中转换结果的作业，然后单击菜单图标。
选择 将结果转换为数据集。
在 将结果转换为数据集 对话框中，为您的数据集提供名称和描述。
单击 转换 以启动转换过程。
转换完成后，您的数据集将显示在“数据集”页面上。
请记住按照 与您的团队共享数据集 中的说明与您的团队或组织中的其他人共享您的数据集。
10.5. 本地暂存空间 (/raid)
所有 Base Command Platform 节点都配备了多个 SSD 驱动器，配置为 RAID-0 阵列缓存存储。此临时空间在每个完整节点作业中都挂载在 /raid。
此 /raid 临时空间的典型用途可以是存储作业完成或终止后不需要的临时结果/检查点。将此本地存储用于中间结果/日志将避免繁重的网络存储访问（例如结果和工作区），并应提高作业性能。此临时空间上的数据在作业完成后会被清除（且不会自动保存/备份到任何其他持久存储）。请将 /raid 视为作业生命周期内可用的临时空间。
由于 /raid 卷是节点的本地卷，因此当作业被抢占并恢复时，其中的数据不会被备份和传输。作业/用户有责任定期将所需的检查点数据备份到可用的网络存储（结果或工作区），以便在抢占后恢复作业（几乎肯定是在不同的节点上）。
用例示例：将已挂载的数据集复制到 /raid 以消除网络延迟。
… -commandline "cp -r /mount/data/ /raid ; bash train.sh /raid/" …
这对于使用大小合理的数据集复制到本地存储的多个 epoch 作业非常有效。请注意，当作业被抢占并恢复时，/raid 卷的内容不会被带到新节点，并且必须将所需信息保存在可用的网络存储空间中，以便使用数据恢复作业。
11. 作业和 GPU 实例
本章介绍 Base Command Platform 的功能，用于将作业提交到 GPU 实例，以及用于管理和与作业交互。在本章中，您将学习如何识别 GPU 实例及其可供您使用的属性，如何定义与关联存储实体相关的作业，以及如何使用 Web UI 或 CLI 管理作业。
11.1. 快速启动作业
Base Command Platform 的快速启动功能为启动交互式作业提供了一个简化的选项。
使用快速启动，管理员可以创建预选了 ACE/计算实例、容器、工作区、数据集等的模板。
用户可以通过 Web UI 或 CLI 轻松启动这些模板，无需配置单个作业，并为他们提供快速简便的访问权限，以启动带有交互式 JupyterLab 会话的预配置作业。
默认情况下创建了两个快速启动模板
JupyterLab - 此简单模板创建一个单节点作业，该作业从指定的容器内启动 JupyterLab。默认情况下，可以使用 PyTorch 或 TensorFlow 基础容器。
Dask & RAPIDS - 此模板启动一个更复杂的多节点 MPI 作业，使用 RAPIDS 容器并在这些节点上启动 Dask 工作节点的集群。JupyterLab 作为此集群的交互点启动。
有关如何使用这些模板启动作业，请参阅以下章节。
重要提示
安全提示： 启动快速启动作业将创建一个 URL 以访问 JupyterLab，任何人都可以使用。有关更多详细信息和安全建议，请参阅 NVIDIA Base Command Platform 术语和概念 中的说明。
11.1.1. JupyterLab 快速启动作业（单节点）
以下说明了 Base Command Platform 用户如何使用快速启动功能启动 JupyterLab 作业。
11.1.1.1. 使用 NGC Web UI
从 Base Command Platform 仪表板，单击快速启动标题下 JupyterLab 卡片上的 启动。
卡片底部显示了要启动的作业类型的详细信息。从左到右，您可以看到
启动时作业可用的 GPU 数量
环境使用的容器
挂载到容器的数据集数量以及是否已选择工作区用于作业。
注意
如果您未选择工作区，则在启动作业时将自动创建一个自定义工作区。
启动作业后，您将被带到作业页面，您可以在其中查看作业详细信息，包括分配的 GPU 数量和作业可用的内存。当 JupyterLab 实例准备就绪时，状态将显示“正在运行”，并且右上角的 启动 JupyterLab 按钮将变为绿色。
单击页面右上角的 启动 JupyterLab。将在新选项卡中启动在卡片上列出的容器内运行的 JupyterLab 环境。
注意
通过快速启动启动的作业的默认运行时间为 60 分钟。
在启动之前，有很多方法可以修改快速启动作业。您可以指定不同的工作区、添加或删除数据集、更改作业将使用的容器以及选择不同的 ACE。
11.1.1.2. 使用 NGC CLI
NGC CLI 支持通过以下命令创建和管理快速启动作业
$ ngc base-command quickstart cluster
您可以使用以下命令语法使用快速启动 CLI 启动 JupyterLab 作业
$ ngc base-command quickstart cluster create --name <cluster name> --ace <ace name> --cluster-lifetime 3600s \
--cluster-type jupyterlab --container-image <container image> --data-output-mount-point /results \
--scheduler-instance-type <instance type> --job-order 50 --job-priority NORMAL --min-time-slice 0s \
--nworkers 1 --org <org> --label quick_start_jupyterlab --workspace-mount <workspace>
示例：启动 JupyterLab 作业
$ ngc base-command quickstart cluster create --name "Quick Start jupyterlab tensorflow ffb4a" \
--ace ceph-sjc-4-ngc-wfs0 --cluster-lifetime 3600s --cluster-type jupyterlab \
--container-image "nvidia/tensorflow:23.08-tf2-py3" --data-output-mount-point /results \
--scheduler-instance-type dgx1v.32g.4.norm --job-order 50 --job-priority NORMAL \
--min-time-slice 0s --nworkers 1 --org nvidia --label quick_start_jupyterlab \
--workspace-mount ZNqskFA0SC2uMGUa4q-5Vg:/bcp/workspaces/49529_quick-start-jupyterlab-workspace_ceph-sjc-4-ngc-wfs0:RW
要查看集群创建命令的完整选项列表，请执行以下操作
$ ngc base-command quickstart cluster create -h
有关快速启动“集群”命令的更多信息，请参阅 NGC CLI 文档。
11.1.2. Dask 和 RAPIDS 快速启动作业（多节点）
所有集群默认都启用了 Dask & RAPIDS 快速启动。（但是，您的帐户管理员可能已禁用此功能。）RAPIDS 库提供了一系列开源 GPU 加速的数据科学库。有关更多信息，请参阅 RAPIDS 文档和资源。Dask 允许您跨多个 GPU 扩展工作负载。有关更多信息，请参阅 Dask 上的文档。当一起使用时，Dask 和 RAPIDS 允许您向上和向外扩展工作负载。
11.1.2.1. 使用 NGC Web UI
从 Base Command Platform 仪表板，单击快速启动标题下 Dask & RAPIDS 卡片上的 启动。
作业将使用卡片上显示的 GPU 数量（每个节点）、Dask 工作节点和容器映像启动。启动后，作业将创建一个将在作业中使用的工作区。
启动作业后，您将被带到作业页面，您可以在其中查看作业详细信息，包括分配的 GPU 数量和作业可用的内存量。当 JupyterLab 实例准备就绪时，状态将显示“正在运行”，并且右上角的 启动 JupyterLab 按钮将变为绿色。
注意
这可能需要长达 10 分钟才能准备就绪。
单击页面右上角的 启动 JupyterLab。将在新选项卡中启动在 Dask & RAPIDS 容器内运行的 JupyterLab 环境。
11.1.2.2. 使用 NGC CLI
NGC CLI 支持通过以下命令创建和管理快速启动作业
$ ngc base-command quickstart cluster
您可以使用以下命令语法使用快速启动 CLI 启动 Dask 和 RAPIDS JupyterLab 作业
$ ngc base-command quickstart cluster create --name <cluster name> --ace <ace name> \
--cluster-lifetime 3600s --cluster-type dask --container-image <container image> \
--data-output-mount-point /results --scheduler-instance-type <instance type> --job-order 50 \
--job-priority NORMAL --min-time-slice 0s --nworkers 1 --org <org> --label quick_start_dask \
--workspace-mount <workspace>
示例：启动 Dask 和 RAPIDS JupyterLab 作业
$ ngc base-command quickstart cluster create --name "Quick Start dask rapidsai-core b3f45" \
--ace ceph-sjc-4-ngc-wfs0 --cluster-lifetime 3600s --cluster-type dask \
--container-image "nvidia/rapidsai-core:cuda11.8-runtime-ubuntu22.04-py3.10" \
--data-output-mount-point /results --scheduler-instance-type dgx1v.32g.8.norm \
--worker-instance-type dgx1v.32g.8.norm --job-order 50 --job-priority NORMAL \
--min-time-slice 0s --nworkers 2 --org nvidia --preempt-class RUNONCE --label quick_start_dask \
--workspace-mount XaoQAFeTQKui6nB0Fr_J7A:/bcp/workspaces/49529_quick-start-dask-workspace_ceph-sjc-4-ngc-wfs0:RW
要查看集群创建命令的完整选项列表，请执行以下操作
$ ngc base-command quickstart cluster create -h
有关快速启动“集群”命令的更多信息，请参阅 NGC CLI 文档。
11.1.3. 自定义快速启动作业的工作区和数据集
如有必要，可以将模板中配置的额外数据集和工作区挂载到您的快速启动作业，以便您可以访问自己的数据并指定自己的工作区来启动作业。
注意
此自定义是临时的，如果您离开仪表板，则不会保存。对于永久性更改，请与您的 Base Command 管理员合作，为快速启动作业创建模板。
从 Base Command Platform 仪表板，单击您要使用的 JupyterLab 快速启动卡片上的数据集和工作区指示器（在本例中为 0 DS / 0 WS）。将打开 数据输入 页面。
在 数据输入 页面中，选择您希望与快速启动作业一起使用的任何数据集和/或工作区。您还可以为数据集指定挂载点。
完成选择后，单击页面底部的 保存更改。
快速启动卡片上的 DS / WS 计数现在将更新，以显示所选数据集和工作区的数量。例如，下面的卡片显示我们选择了两个数据集和一个工作区。
单击 启动。作业将使用所选的工作区（如果未选择工作区，则创建默认工作区），并将任何选定的数据集挂载到相应的挂载点。
作业创建后，您将被带到作业页面，您可以在其中查看详细信息，包括分配的 GPU 数量和作业可用的内存。当 JupyterLab 实例准备就绪时，状态将显示“正在运行”，并且右上角的 启动 JupyterLab 按钮将变为绿色。
单击作业页面右上角的 启动 JupyterLab 按钮，一旦它从灰色变为绿色。将在新选项卡中启动在卡片上列出的容器内运行的 JupyterLab 环境。
11.1.3.1. 自定义 Dask 和 RAPIDS 快速启动作业的工作节点数量
默认的 Dask & RAPIDS 快速启动作业以 14 个工作节点的集群启动。
这些工作节点是 Dask 工作节点，每个节点（副本）消耗一个 GPU。默认情况下，Jupyterlab 和 Dask 调度器使用两个 GPU（每个一个），Dask 工作节点使用 14 个（每个一个），总共 16 个 GPU。因此，此默认作业将跨越两个节点（假设每个节点/副本八个 GPU）。每个额外的节点最多支持八个工作节点。例如，15-22 个工作节点将使用三个节点，23-30 个工作节点将使用四个节点。
要更改作业的 Dask 工作节点数量
从 Base Command Platform 仪表板，单击 Dask & RAPIDS 快速启动卡片底部的 工作节点。
使用 + 和 - 按钮选择您希望使用 Dask 工作节点的数量。选择后，单击 保存更改。
快速启动卡片将显示更新的工作节点数量。单击 启动 以启动作业。
11.1.4. 从模板启动快速启动作业
组织管理员可以为用户提供模板。这些模板允许用户使用不同的 ACE、容器、数据集和工作区挂载默认值快速启动快速启动环境。
从 Base Command Platform 仪表板，单击您要运行的快速启动作业右上角的垂直省略号，然后选择 从模板启动。
在窗口中，您将看到可供您使用的模板列表，包括每个模板使用的容器、数据输入和计算资源的详细信息。选择您要使用的模板，然后单击 使用模板启动 以从该模板启动 JupyterLab 快速启动。
创建作业后，您将被带到作业页面。准备就绪后，您可以单击右上角的 启动 JupyterLab。
注意
只有平台管理员可以创建新模板并使其可供 Base Command Platform 用户使用。有关如何创建新模板的详细信息，请参阅以下说明。
11.1.5. 启动自定义快速启动作业
自定义快速启动作业允许您使用任一模板启动作业，同时指定 ACE 和启动容器，以及您希望公开的任何其他端口。
从 Base Command Platform 仪表板，对于您要从中开始的快速启动模板，单击模板右上角的垂直省略号，然后选择 自定义启动。
您将通过一个多步骤 自定义启动 菜单进行引导。要移动到下一阶段，请单击右下角的绿色“下一步”按钮。
首先，选择一个 ACE。选择 ACE 后，将显示关联的实例。选择您要使用的实例。
接下来，如果使用 Dask & RAPIDS（多节点）模板，系统将提示您选择工作节点的数量。此步骤在 JupyterLab（单节点）模板中不会出现。
接下来，您可以选择容器和协议。使用下拉菜单选择容器。您还必须选择容器标签。
注意
只有列为“快速启动验证”的容器才经过测试可与快速启动自定义启动一起使用。您可以选择不同的容器；但是，这可能会导致您的作业失败。我们验证容器的倒数第二个版本。要使用最新的容器，我们建议您启动自定义作业。
您还可以选择要从正在运行的作业中公开的协议和容器端口。使用快速启动验证的容器时，您不应公开 JupyterLab 的端口 8888，因为此端口会自动公开。
接下来，选择您希望在容器内挂载的任何数据集以及您要使用的工作区。
单击 启动 JupyterLab 以启动作业。
重要提示
安全提示： 当打开容器的端口时，它将创建一个 任何人都可以使用 的 URL。有关更多详细信息和安全建议，请参阅 NVIDIA Base Command Platform 术语和概念 中的说明。要启动安全作业，请按照 运行简单作业 的说明进行操作。
11.1.6. 创建新的快速启动模板
本节适用于管理员（具有组织级别的 BASE_COMMAND_ADMIN 角色），并描述了为 NVIDIA Base Command Platform 用户创建和激活模板的过程。
11.1.6.1. 使用 NGC Web UI
从 Base Command Platform 仪表板，单击任何现有快速启动卡片右上角的垂直省略号。单击 从模板启动。
单击菜单左上角的 + 创建新模板。
您将通过一个多步骤 创建新模板 菜单进行引导。要移动到下一阶段，请单击右下角的绿色“下一步”按钮。
首先，选择一个 ACE。选择 ACE 后，将显示关联的实例。选择您要使用的实例。
接下来，如果使用 Dask & RAPIDS（多节点）模板，系统将提示您选择工作节点的数量。此步骤在 JupyterLab（单节点）模板中不会出现。
接下来，选择容器和（可选）协议。使用下拉菜单选择容器。您还必须选择容器标签。
注意
只有列为“快速启动验证”的容器才经过测试可与快速启动自定义启动一起使用。您可以选择不同的容器；但是，这可能会导致您的作业失败。我们验证容器的倒数第二个版本。要使用最新的容器，我们建议您启动自定义作业。
接下来，选择您希望在容器内挂载的任何数据集以及您可能希望使用的工作区（如果适用）。
单击 创建 JupyterLab 模板。
此模板现在可供用户使用，并且可以在 从模板启动 菜单下的模板列表中找到，该菜单可以从快速启动卡片右上角的垂直省略号访问。
11.1.6.2. 使用 NGC CLI
NGC CLI 支持通过以下命令创建和管理快速启动模板
$ ngc base-command quickstart project
您可以使用以下命令语法使用快速启动 CLI 创建 JupyterLab 模板
$ ngc base-command quickstart project create-template \
--name <template name> \
--description <template description> \
--display-image-url <template image URL> \
--ace <ace name> \
--cluster-lifetime 3600s \
--cluster-type jupyterlab \
--container-image <container image> \
--data-output-mount-point /results \
--scheduler-instance-type <instance type> \
--job-order 50 \
--job-priority NORMAL \
--min-time-slice 1s \
--nworkers 2 \
--org <org name> \
--label <job labels> \
--workspace-mount <workspace mountpoint>
示例：创建 TensorFlow JupyterLab 模板
$ ngc base-command quickstart project create-template \
--name "demo tensorflow template" \
--description "demo" \
--display-image-url "https://demo/demo-image.png" \
--ace ceph-sjc-4-ngc-wfs0 \
--cluster-lifetime 3600s \
--cluster-type jupyterlab \
--container-image "nvidia/tensorflow:23.08-tf2-py3" \
--data-output-mount-point /results \
--scheduler-instance-typedgx1v.32g.4.norm \
--job-order 50 \
--job-priority NORMAL \
--min-time-slice 1s \
--nworkers 2 \
--org nvidia \
--label "tf template" \
--workspace-mount ZNqskFA0SC2uMGUa4q-5Vg:/bcp/workspaces/49529_quick-start-jupyterlab-workspace_ceph-sjc-4-ngc-wfs0:RW
示例：创建 PyTorch Jupyter 模板
$ ngc base-command quickstart project create-template \
--name "demo pytorch template" \
--description "demo" \
--display-image-url "https://demo/demo-image.png" \
--ace ceph-sjc-4-ngc-wfs0 \
--cluster-lifetime 3600s \
--cluster-type jupyterlab \
--container-image "nvidia/pytorch:23.08-py3" \
--data-output-mount-point /results \
--scheduler-instance-typedgx1v.32g.4.norm \
--job-order 50 \
--job-priority NORMAL \
--min-time-slice 1s \
--nworkers 2 \
--org nvidia \
--label "tf template" \
--workspace-mount ZNqskFA0SC2uMGUa4q-5Vg:/bcp/workspaces/49529_quick-start-jupyterlab-workspace_ceph-sjc-4-ngc-wfs0:RW
要查看模板命令的完整选项列表，请执行以下操作
$ ngc base-command quickstart project -h
有关快速启动“项目”命令的更多信息，请参阅 NGC CLI 文档。
11.1.7. 更改默认快速启动模板
本节适用于管理员（具有组织级别的 BASE_COMMAND_ADMIN 角色），并描述了更改 Base Command Platform 仪表板上显示的每个快速启动作业卡片的默认模板的过程。
从 Base Command Platform 仪表板，单击任何现有快速启动卡片右上角的垂直省略号。单击 从模板启动。
单击您要设置为默认模板的模板右侧的垂直省略号。
单击 设置为默认模板。刷新仪表板后，默认设置将为所有用户更新。
11.1.8. 更新现有快速启动模板
本节适用于管理员（具有组织级别的 BASE_COMMAND_ADMIN 角色），并描述了为 NVIDIA Base Command Platform 用户更新模板的过程。
可以更新现有的快速启动模板，用户可以选择这些模板作为其他启动选项，如 从模板启动快速启动作业 中所述。
从 Base Command Platform 仪表板，单击任何现有快速启动卡片右上角的垂直省略号。单击 从模板启动。
单击您要编辑的模板右侧的垂直省略号。
单击 编辑模板。按照类似于 使用 NGC Web UI 创建新的快速启动模板 的步骤，更新现有模板。
11.2. 运行简单作业
本节介绍如何运行简单的“Hello world”作业。
登录到 NGC 门户，然后从左侧导航菜单中单击 BASE COMMAND > 作业。
在右上角选择 创建作业。
从 ACE 下拉菜单中选择您的加速计算环境和实例类型。
在 数据输出 下，选择一个挂载点以访问结果。
挂载点可以是容器中尚不存在的任何路径。结果挂载点通常为 /result 或 /results。
在 容器选择 区域下
从下拉菜单中选择容器映像和标签，例如
nvidia/tensorflow:22.12-tf1-py3在 运行命令 下输入 bash 命令；例如，
echo 'Hello from NVIDIA'。
在屏幕底部，输入您的作业名称。
您可以选择为您的作业添加自定义标签。
单击页面右上角的 启动作业。
或者，如果您已安装 NGC CLI，请单击命令框中的复制图标，然后将命令粘贴到命令行中。
启动作业后，您将被带到作业页面，并在列表顶部看到您的新作业，其状态为 已排队 或 正在启动。
此作业将运行该命令（输出可以在 日志 选项卡中查看）。状态历史记录 选项卡报告以下进度以及时间戳：已创建 -> 已排队 -> 正在启动 -> 正在运行 -> 完成。
11.3. 在作业中运行 JupyterLab
本节介绍如何运行包含 JupyterLab 的简单“Hello world”作业。
NGC 容器在容器映像中包含 JupyterLab。使用 JupyterLab 是一种运行笔记本、获取 shell 访问权限（多个会话）、运行 tensorboard 以及在一个浏览器窗口中拥有文件浏览器和文本编辑器的便捷方式。在作业中在后台运行它是非侵入性的，没有任何额外的性能影响或工作量，并为您提供了一个随时查看作业的简便选项。
重要提示
安全提示： 当打开容器的端口时，它将创建一个 任何人都可以使用 的 URL。有关更多详细信息和安全建议，请参阅 NVIDIA Base Command Platform 术语和概念 中的说明。
11.3.1. 在作业中运行 JupyterLab 的示例
以下是在作业中利用 JupyterLab 的作业示例。
$ ngc base-command run --name "jupyterlab" --instance <INSTANCE_NAME> \
--commandline "jupyter lab --ip=0.0.0.0 --allow-root --no-browser --NotebookApp.token='' \
--notebook-dir=/ --NotebookApp.allow_origin='*'" \
--result /result --image "nvidia/pytorch:23.01-py3" --port 8888
以下是在您的作业中使用 JupyterLab 的一些关键方面。
在作业定义中指定 --port 8888。
作业必须公开 Jupyter lab 端口（默认为 8888）。
JupyterLab 命令必须以“jupyter lab”开头。
总运行时间应设置为合理的数字，以便在容器完成作业并关闭之前访问容器
11.3.2. 连接到 JupyterLab
当作业处于运行状态时，您可以通过映射的 URL 连接到 JupyterLab，如下所示。
在网站上，单击作业详细信息页面的 映射端口 部分中显示的 URL。
在 CLI 中，运行 $ ngc base-command info <job-id >，然后复制端口映射行中的 URL 并粘贴到浏览器中。
JupyterLab 示例:
11.4. 克隆现有作业
您可以克隆作业，当您想从现有作业开始并为新作业进行少量更改时，这非常有用。
从左侧导航菜单中单击 作业，然后单击要复制的作业的省略号菜单，并从菜单中选择 克隆作业。
创建作业页面打开，其中字段填充了克隆作业的信息。
根据需要编辑字段以创建新作业，在 名称 字段中输入唯一名称，然后单击 启动。
作业应显示在作业仪表板中。
要通过 CLI 克隆作业，请使用 --clone 标志，并添加其他标志以覆盖从原始作业复制的任何参数。
$ ngc base-command run --clone <job-id> --instance dgx1v.32g.8.norm
11.5. 从模板文件启动作业
从左侧菜单中单击 Base Command > 作业 > 创建，然后从功能区菜单中单击 从模板创建。
单击要使用的模板的菜单图标，然后选择 应用模板。
创建作业页面打开，其中字段填充了作业模板的信息。
根据需要编辑字段以创建新作业，或保持字段不变，然后单击 启动。
11.6. 使用 JSON 文件启动作业
当从 CLI 重复运行作业时，有时使用模板文件比命令行标志更容易。JSON 目前支持此功能。以下各节介绍如何从作业模板生成 JSON 文件以及如何在 CLI 中使用它。
11.6.1. 使用 Web UI 生成 JSON
执行以下操作以使用 NGC Web UI 生成 JSON 文件。
从左侧菜单中单击 仪表板，单击搜索栏旁边的表格视图图标，然后单击要复制的作业的菜单图标，并选择 复制到 JSON。
JSON 将复制到您的剪贴板。
打开一个空白文本文件，将内容粘贴到文件中，然后使用扩展名 .json 保存文件。
示例：
test-json.json要从文件运行作业，请执行以下操作
$ ngc base-command run -f <file.json>
11.6.2. 使用 CLI 生成 JSON
或者，如果您知道作业 ID，也可以使用 CLI 获取 JSON，如下所示
$ ngc base-command get-json <job-id> > <path-to-json-file>
JSON 将复制到指定的路径和文件。
示例:
$ ngc base-command get-json 1234567 > ./json/test-json.json
要从文件运行作业，请执行以下操作
$ ngc base-command run -f <file.json>
示例:
$ ngc base-command run -f ./json/test-json.json
11.6.3. 覆盖 JSON 文件中的字段
以下是 JSON 示例
{
"dockerImageName": "nvidia/tensorflow:19.11-tf1-py3",
"aceName": "nv-us-west-2",
"name": "test.exempt-demo",
"command": "jupyter lab --ip=0.0.0.0 --allow-root --no-browser --NotebookApp.token='' --notebook-dir=/ --NotebookApp.allow_origin='*' & date; sleep 1h",
"description": "sample command description",
"replicaCount": 1,
"publishedContainerPorts": [
8888,
6006
],
"runPolicy": {
"totalRuntimeSeconds": 3600,
"premptClass": "RUNONCE"
},
"workspaceMounts": [
{
"containerMountPoint": "/mnt/democode",
"id": "KUlaYYvXT56IhuKpNqmorQ",
"mountMode": "RO"
}
],
"aceId": 257,
"networkType": "ETHERNET",
"datasetMounts": [
{
"containerMountPoint": "/data/imagenet",
"id": 59937
}
],
"resultContainerMountPoint": "/result",
"aceInstance": "dgx1v.32g.8.norm.beta"
}
您可以在命令中指定其他参数，但如果在 JSON 文件中指定了这些参数，则参数值将覆盖 JSON 文件中的值。
请参阅下表，了解模板中字段到命令行中选项名称的映射。
CLI 选项 |
JSON 键 |
|---|---|
|
command |
|
description |
|
none |
|
none |
|
dockerImageName |
|
aceInstance |
|
name |
|
port（传入端口列表 [8888,6006]） |
|
workspaceMounts（传入对象列表） |
|
ace |
|
none |
|
none |
|
datasetMounts（传入对象列表） |
|
none |
|
none |
|
none |
|
none |
|
none |
|
networkType |
|
none |
|
runPolicy[preemptClass] |
|
replicaCount |
|
resultContainerMountPoint |
|
none |
|
none |
|
none |
|
none |
|
runPolicy[totalRuntimeSeconds] |
|
none |
|
none |
|
none |
示例
假设文件 pytorch.json 是前面提到的 JSON 示例文件，则以下命令将使用实例 dgx1v.16g.2.norm 而不是 JSON 中指定的实例 dgx1v.16g.1.norm。
$ ngc base-command run -f pytorch.json --instance dgx1v.16g.2.norm
以下是覆盖 JSON 参数的更多示例
$ ngc base-command run -f pytorch.json --instance dgx1v.16g.4.norm --name "Jupyter Lab repro ml-model.exempt-repro"
$ ngc base-command run -f pytorch.json --image nvcr.io/nvidia/pytorch:20.03-py3
11.7. 使用 CLI 进入正在运行的作业
要进入正在运行的容器，请执行以下操作
$ ngc base-command exec <job_id>
要在正在运行的容器中执行命令，请执行以下操作
$ ngc base-command exec --commandline "command" <job_id>
使用 bash 的示例
$ ngc base-command exec --commandline "bash -c 'date; echo test'" <job_id>
11.8. 附加到正在运行的作业的控制台
当作业处于运行状态时，您可以从 Web UI 和使用 CLI 附加到作业的控制台。控制台日志显示来自 STDOUT 和 STDERR 的输出。这些日志也保存到结果挂载位置的 joblog.log 文件中。
$ ngc base-command attach <job_id>
11.9. 管理作业
本节介绍各种作业管理任务。
11.9.1. 检查作业名称、ID、状态和结果
11.9.1.1. 使用 NGC Web UI
登录到 NGC 网站，然后从左侧导航菜单中单击 Base Command > 作业。
作业页面列出了您运行的所有作业，并显示状态、作业名称和 ID。
状态列报告以下进度以及时间戳：已创建 -> 已排队 -> 正在启动 -> 正在运行 -> 完成。
当作业处于“已排队”状态时，Web UI 中的“状态历史记录”选项卡会显示“已排队”状态的原因。CLI 上的作业信息命令也会显示此详细信息。
完成后，从“作业”页面单击您的作业条目。结果 和 日志 选项卡都显示您的作业产生的输出。
11.9.1.2. 使用 CLI
使用 CLI 启动作业后，输出会确认启动成功并显示作业详细信息。
示例:
--------------------------------------------------
Job Information
Id: 1854152
Name: ngc-batch-simple-job-raid-dataset-mnt
Number of Replicas: 1
Job Type: BATCH
Submitted By: John Smith
Job Container Information
Docker Image URL: nvidia/pytorch:21.02-py3
...
Job Status
Created at: 2021-03-19 18:13:12 UTC
Status: CREATED
Preempt Class: RUNONCE
----------------------------------------
“已创建”的作业状态表示刚刚启动的作业。
您可以通过发出以下命令来监控作业的状态
$ ngc base-command info <job-id>
这将返回与启动作业后显示的相同作业信息，并包含更新的状态信息。
要查看正在运行的作业的 stdout/stderr，请执行以下操作
$ ngc base-command attach <job-id>
所有 NGC Base Command Platform CLI 命令都有其他选项；发出 ngc --help 以了解详细信息。
11.9.2. 监控控制台日志 (joblog.log)
作业输出（STDOUT 和 STDERR）都捕获在 joblog.log 文件中。
有关结果日志记录行为的更多信息，请参阅 管理结果。
11.9.2.1. 使用 NGC Web UI
要查看作业的日志，请从 作业 页面中选择作业，然后选择 日志 选项卡。从这里，您可以查看每个节点的 joblog.log
注意
如果使用 “MPI” 数组类型运行多节点作业，则只有来自第一个节点（副本 0）的日志将包含内容。默认行为是将所有节点的 STDOUT 和 STDERR 输出流式传输到第一个节点（副本 0）上的 joblog.log 文件中。因此，其他节点上的其余日志文件将为空。
11.9.2.2. 使用 CLI
发出以下命令
$ ngc result download <job-id>
来自所有节点的 joblog.log 文件和 STDOUT/STDERR 都包含在结果中，这些结果将下载到本地磁盘当前目录中标注为 job-id 的文件夹中。
要查看正在运行的作业的 STDOUT/STDERR，请发出以下命令
$ ngc base-command attach <job-id>
11.9.3. 下载结果（中期和完成后）
11.9.3.1. 使用 NGC Web UI
要下载作业结果，请执行以下操作
从 作业 页面中选择作业，然后选择 结果 选项卡。
从“结果”页面中，选择要下载的文件。
文件将下载到您的“下载”文件夹。
11.9.3.2. 使用 CLI
发出以下命令
$ ngc result download <job_id>
结果将下载到本地磁盘当前目录中标注为 <job_id> 的文件夹中。
11.9.4. 终止作业
11.9.4.1. 使用 NGC Web UI
要从 NGC 网站终止作业，请等待作业出现在“作业”页面中，然后单击作业的菜单图标并选择 终止作业。
11.9.4.2. 使用 CLI
记下启动作业后的作业 ID，然后发出以下命令
$ ngc base-command kill <job-id>
示例:
$ ngc base-command kill 1854178
已提交 作业 终止 请求 ，作业 ID： '1854178'
您还可以使用一个命令终止多个作业，方法是将多个作业 ID 列为逗号分隔的 ID 和范围的组合；例如 ‘1-5’、‘333’、‘1, 2’、‘1,10-15’。
11.9.5. 删除结果
结果将保留在系统中，占用配额，直到被删除
$ ngc result remove <job_id>
11.10. 标记作业
本节介绍如何在提交作业时创建自定义标签，以及之后使用这些标签的方法。
标签可用于对相似的作业进行分组或分类，或用于搜索和筛选作业。
标签具有以下要求和限制
标签可以使用字母数字字符和“_”（下划线）创建，长度最多为 256 个字符。
以“_”（下划线）开头的标签保留用于特殊目的。特殊用途功能计划在未来的版本中推出。
每个作业最多可以有 20 个标签。
11.10.1. 创建标签
类别名称 |
描述 |
预期值 |
|---|---|---|
普通 |
可以由任何有权访问作业的用户生成。 |
字母数字字符和“_”（下划线），最多 256 个字符，并且不能以“_”开头。 |
管理员标签 |
只能由管理员生成、添加和删除。 |
以双下划线 “__” 开头的标签。 |
系统标签 |
定义系统行为的标签。从预生成的列表中选择，并由任何有权访问作业的人员添加或删除。 |
以单下划线 “_” 开头的标签。 |
系统标签 |
_locked_labels |
如果存在此标签，则禁止任何人添加或删除任何其他标签。 |
11.10.1.1. 使用 NGC Web UI
在 创建作业 页面的“启动作业”部分中，在 自定义标签 字段中输入标签。按 Enter 应用更改。
您还可以指定多个标签将一个作业分类到多个组中，前提是您一次添加一个标签（即，在输入每个标签后按 Enter）。
示例:
创建自定义标签 “nv_test_job_label_1001”
11.10.1.2. 使用 CLI
您可以在使用 CLI 提交作业时动态分配作业标签。
对于单个标签，发出以下命令
$ ngc base-command run .. --label <label_1>
对于多个标签，发出以下命令
$ ngc base-command run .. --label <label_1> --label <label_2>
系统管理员可以创建以 __（双下划线）开头的标签。
$ ngc base-command run .. --label <__some_label>
11.10.2. 修改标签
作业的标签可以在作业的生命周期内的任何时间更改，只要它们未被锁定。
11.10.2.1. 使用 NGC Web UI
要修改作业标签，请执行以下操作
在 自定义标签 字段中，单击标签上的 “X” 以删除。
添加新标签并按 Enter。
11.10.2.2. 使用 CLI
以下示例显示了修改作业中标签的方法。
清除（删除）作业中的所有标签
$ ngc base-command update .. --clear-label <job-id>
向作业添加标签
$ ngc base-command update .. --label "__bad" <job-id>锁定当前分配给作业的所有标签
$ ngc base-command update .. --lock-label <job-id>
解锁当前分配给作业的所有标签
$ ngc base-command update .. --unlock-label <job-id>
从作业中删除特定标签
$ ngc base-command update .. --remove-label "test*" --remove-label "try" <job-id>
管理系统标签（以 __ 双下划线开头）只能由具有管理员权限的用户删除。
11.10.3. 搜索/排序标签
您可以使用通配符 * 和 ? 搜索标签，并使用包含/排除模式进行筛选。所有用户都可以搜索保留标签。使用多个标签进行搜索将返回具有任何列出标签的作业。搜索模式也不区分大小写。
11.10.3.1. 使用 NGC Web UI
在搜索字段中输入搜索词，然后按 Enter。
示例:
搜索标签以 “nv_test_job_label*” 开头的作业
搜索结果如下
11.10.3.2. 使用 CLI
您可以从搜索中排除某些标签。
以下示例列出了所有带有 “Pytorch” 标签但没有 “bad” 标签的作业
$ ngc base-command list --label "Pytorch" --exclude-label "bad"
以下是一些使用排除选项的其他示例
$ ngc base-command list --label "__tutorial" --exclude-label "qsg"
$ ngc base-command list --label "delete" --exclude-label "publish"
以下示例列出了除标签 “aaa” 之外的所有标签
$ ngc base-command list --label * --exclude-label "aaa"以下示例使用逗号分隔符列出多个标签，这将列出带有标签 “Pytorch” 和/或 “active” 的作业（不区分大小写）
$ ngc base-command list --label "Pytorch","active"
11.10.4. 查看标签
您可以使用以下方法查看作业标签。
11.10.4.1. 使用 CLI
示例:
要查看组织内定义或使用的所有标签的列表，请发出以下命令
$ ngc base-command list --column labels
示例:
要查看特定作业的标签
$ ngc base-command info <jobid>
标签列表按以下顺序返回
系统定义的标签（以下划线 “_” 开头）
管理员添加的标签（以双下划线 “__” 开头）
其他标签（按字母顺序排序）
11.10.5. 克隆/模板化作业
当作业被克隆或从模板创建时，自定义标签会被保留，而系统标签或保留标签默认会被删除。
有关更多信息，请参阅用户指南中的 克隆现有作业。
11.10.5.1. 使用 NGC Web UI
在 基本命令 > 作业 页面中，单击 “…” 菜单并选择 克隆作业。
请注意，自定义标签在新克隆的作业中被保留。
11.10.5.2. 使用 CLI
以下是使用克隆选项的示例
$ ngc base-command run .. -f jobdef.json --label "copy","rerun"
11.11. 调度作业
默认情况下，如果资源和配额可用，作业将按照提交顺序运行。有时，需要将高优先级作业排在其他作业之前提交。可以设置 order 和 priority 两个标志，以便更好地控制作业的运行时间。
优先级可以是 HIGH、NORMAL 或 LOW。
Order 可以是 1 到 99 之间的整数，数字越小，执行越早。
默认情况下，优先级为 NORMAL，order 为 50。
标志 |
值 |
默认值 |
描述 |
|---|---|---|---|
Order |
[1-99] |
50 |
仅影响您的作业的执行顺序。 |
Priority |
[HIGH、NORMAL、LOW] |
NORMAL |
影响集群上所有作业的执行顺序。 |
11.11.1. 作业顺序
作业可以分配一个 1 到 99 的 order 数字（默认为 50），数字越小，执行越早。Order 数字仅更改优先级相同的作业的顺序，不会影响其他用户的作业的执行。Order 不会影响抢占行为。
11.11.2. 作业优先级
优先级可以是 HIGH、NORMAL（默认）或 LOW。每个优先级实际上是集群上的一个单独队列。较高优先级队列中的所有作业将在较低优先级队列中的作业之前运行，甚至会在提交为 RESUMABLE 时抢占较低优先级的作业。由于这可能导致 NORMAL 优先级作业在超额订阅的集群中被饿死，因此您更改作业优先级的权限必须由您的团队或组织管理员启用。
在此单个用户的队列示例中，作业将从上到下执行。
Priority |
Order |
|---|---|
HIGH |
1 |
HIGH |
50 |
NORMAL |
10 |
NORMAL |
50 |
NORMAL |
50 |
NORMAL |
99 |
LOW |
50 |
以下说明了如何在提交作业时设置 order 和 priority。将 -h 或 --help 附加到命令将提供有关其标志的更多信息。
$ ngc base-command run --name test-order ... --order 75 --priority HIGH
--------------------------------------------------------
Job Information
Id: 1247749
Name: test-order
...
Order: 75
Priority: HIGH
您还可以在列出作业时查看 order 和 priority 值。
$ ngc base-command list --column order --column priority
+---------+-------+----------+
| Id | Order | Priority |
+---------+-------+----------+
| 1247990 | 75 | HIGH |
| 1247749 | 75 | HIGH |
| 1247714 | 12 | HIGH |
| 1247709 | 50 | NORMAL |
| 1247638 | 99 | HIGH |
| 1247598 | 35 | NORMAL |
+---------+-------+----------+
# Filtering only the high priority jobs
$ ngc base-command list --priority HIGH --column order --column priority
+---------+-------+----------+
| Id | Order | Priority |
+---------+-------+----------+
| 1247990 | 75 | HIGH |
| 1247749 | 75 | HIGH |
| 1247714 | 12 | HIGH |
| 1247638 | 99 | HIGH |
+---------+-------+----------+
注意：由于当前版本的限制，以下是更改作业 order 或 priority 的步骤。
克隆作业。
在提交之前，设置克隆作业的 order 和 priority。
删除旧作业。
11.11.3. 配置作业抢占
对作业抢占的支持是集群启用基于优先级的任务调度和执行以及提高资源利用率、适应性、公平性和饥饿处理能力的基本要求。在较小的集群中尤其如此，这些集群往往在高负载条件下运行，并且调度成为影响收入和用户体验的关键组件。
NGC 集群中的作业抢占结合了用户驱动的抢占和恢复支持、调度程序驱动的系统抢占以及操作驱动的自动节点排空支持。作业抢占针对一类称为可恢复作业的特定作业（--preempt RESUMABLE）。NGC 中的可恢复作业的优势在于，与 “run once” 作业相比，它们被允许在集群上运行更长的总运行时间。
11.11.3.1. 在作业中启用抢占
要启用抢占功能，用户需要使用以下标志启动作业
--preempt
--min-timeslice XX
11.11.3.2. 使用 --preempt 标志
--preempt 标志接受以下参数。
--preempt <RUNONCE | RESUMABLE | RESTARTABLE>
其中
RUNONCE：是默认条件，指定作业不重新启动。可能需要此条件以避免失败作业采取不利操作。
RESUMABLE：允许作业在使用启动作业的同一命令在抢占后从中断处恢复。通常适用于具有定期检查点的长达一周的模拟、几乎所有 HPC 应用和 DL 框架以及无状态作业。
RESTARTABLE：（当前不支持）指定如果作业被抢占，则必须从初始状态重新启动。通常适用于恢复比重新启动工作量更大的短作业、没有恢复能力的软件或没有工作区作业。
11.11.3.3. 使用 --min-timeslice 标志
用户必须提供指定最小时间片的附加选项，即可恢复作业在进入运行状态后保证运行的最短时间。此选项允许用户指定一个时间窗口，在此窗口期间，作业可以在抢占之前和对其状态进行检查点之前取得足够的进展，以便作业可以在被抢占时恢复。指定较小的时间片可能有助于用户在高负载条件下更快地调度其作业。
11.11.3.4. 管理检查点
用户负责管理其工作区中的检查点。
他们可以通过在作业脚本中添加这些可控属性来实现此目的。
训练脚本以常规间隔保存检查点。
在恢复训练时，脚本应读取现有检查点并从最新的已保存检查点恢复训练。
11.11.3.5. 抢占作业
要抢占作业，请使用 ngc base-command preempt 命令。
语法
$ ngc base-command preempt <job_id>
11.11.3.6. 恢复已抢占的作业
要抢占作业，请使用 ngc base-command resume 命令。
语法
$ ngc base-command resume <job_id>
示例工作流程
启动一个 preempt 设置为 “RESUMABLE” 的作业。
$ ngc base-command run --name "preemption-test" --preempt RESUMABLE --min-timeslice 300s --commandline python train.py --total-runtime 72000s --ace nv-eagledemo-ace --instance dgxa100.40g.1.norm --result /results --image "nvidia/pytorch:21.02-py3" -------------------------------------------------- Job Information Id: 1997475 Name: preemption-test Number of Replicas: 1 Job Type: BATCH Submitted By: John Smith ...
此工作负载使用 Pytorch 容器并运行一个虚拟训练脚本
train.py。作业运行后，您可以抢占它。
$ ngc base-command preempt 1997475已提交作业抢占请求，作业 ID：‘1997475’
要恢复已抢占的作业，请发出
ngc base-command resume命令。$ ngc base-command resume 1997475 Submitted job resume request for Job ID: '1997475'
NGC Base Command Platform Web 应用程序上的作业“状态历史记录”显示了其进度。
12. 遥测
本章介绍 Base Command Platform 的系统遥测功能。在本章中，您将了解从工作负载收集并在 UI 中绘制的不同指标，使您能够近乎实时地（大约 30 秒）监控工作负载的效率。可以使用 Web UI 和 CLI 访问遥测数据。
NVIDIA Base Command Platform 为作业提供系统遥测信息，并允许作业将遥测数据发送到 Base Command Platform 进行记录。此信息（在 Base Command Platform 仪表板中绘制，也可在未来的版本中通过 CLI 获取）对于提供作业运行情况的可视性非常有用。这使用户可以
优化作业。
调试作业。
分析作业效率。
作业遥测由 Base Command Platform 自动生成，并提供作业的 GPU、Tensor Core、CPU、GPU 内存和 IO 使用率信息。
下表提供了在 Base Command Platform 遥测功能中测量和跟踪的所有指标的描述
注意
对于每个 GPU 测量的属性给出的单个数字，默认情况下将是平均值。
指标 |
定义 |
|---|---|
作业运行时长 |
作业处于 RUNNING 状态的时长 (HH:MM:SS) |
GPU 活动时间 |
在整个作业期间，GPU 上的图形引擎处于活动状态的时间百分比（GPU 活动百分比 > 0%）。 |
GPU 利用率 |
要观察的主要指标之一。它定义为在过去一秒内运行一个或多个 GPU 内核的时间百分比，这类似于作业正在利用 GPU。 |
GPU 活动百分比 |
处于活动状态的 GPU 内核的百分比。如果绑定了图形/计算上下文，并且图形管道或计算管道正忙，则图形引擎处于活动状态。实际上是每个 GPU 的 GPU 利用率。 |
Tensor Core 活动百分比 |
张量 (HMMA) 管道处于活动状态的周期百分比（相对于峰值持续经过的周期）。 |
GPU 内存活动 |
此指标表示 GPU 的内存控制器用于从内存读取或写入内存的时间百分比。 |
GPU 功耗 |
显示每个 GPU 使用的功率（以瓦特为单位），以及其总可能功率消耗的百分比。 |
GPU 已用内存 (GB) |
此指标显示已使用了多少 GPU 显存。 |
PCIe 读取/写入 BW |
此指标指定活动 PCIe 读取/传输数据的字节数，包括标头和有效负载。 请注意，这是从 GPU 的角度来看的，因此从主机复制数据到设备 (HtoD) 或从设备复制数据到主机 (DtoH) 将反映在这些指标中。 |
CPU 使用率 |
此指标给出随时间变化的 CPU 使用率百分比。 |
系统内存 |
作业正在使用的系统内存总量（以 GB 为单位）。 |
Raid 文件系统 |
/raid 文件夹中的数据量。默认情况下，最大值为 2 TB。更多信息请参见 本地暂存空间。 |
[数据集 | 工作区 | 结果] IOPS 读取 |
每秒访问已挂载的 [数据集 | 工作区 | 结果] 文件夹的读取操作数。 |
[数据集 | 工作区 | 结果] IOPS 写入 |
每秒访问已挂载的 [数据集 | 工作区 | 结果] 文件夹的写入操作数。 |
[数据集 | 工作区 | 结果] BW 读取 |
显示从已挂载的 [数据集 | 工作区 | 结果] 文件夹读取的数据总量（以 GB 为单位）。 |
[数据集 | 工作区 | 结果] BW 写入 |
显示写入到已挂载的 [数据集 | 工作区 | 结果] 文件夹的数据总量。 |
网络 BW [TX | RX] |
显示从作业传输 (TX) 和作业接收 (RX) 的数据总量。 |
NV Link BW [TX | RX] |
显示正在使用的 NVLink 带宽（以 GB/s 为单位）。NVLink direct 是同一节点上 GPU 的 GPU-GPU 互连。这是多节点作业的每个副本指标，以及部分节点工作负载的每个节点指标。 |
12.1. 从 NGC Web UI 查看遥测信息
单击 作业，选择您的一个作业，然后单击 遥测 选项卡。
以下是“遥测”选项卡的示例屏幕截图。
注意
屏幕截图仅用于示例目的 - 确切外观可能会因 NGC 版本而异。
浮动窗口给出了每个时间片的遥测指标细分，以便更详细地了解指标。
对于每个 GPU 测量的属性给出的单个数字，默认情况下是平均值，但我们也可以使用下拉菜单可视化最小值或最大值统计信息。
查看最小统计信息中的遥测数据
查看最大统计信息中的遥测数据
我们可以在浮动窗口中看到每个 GPU 的指标，如下所示。
遥测数据在顶部显示了总体 GPU 利用率和 GPU 活动百分比以及作业运行时长。之后，我们在遥测的每个部分都有更详细的信息。
GPU 活动、Tensor Core 活动、GPU 内存活动和 GPU 功耗
GPU 已用内存
PCIe 读取和写入 BW
NVLink BW
CPU 使用率和系统内存
12.2. 多节点作业的遥测
默认情况下，遥测数据显示所有节点的平均值。通过单击 选择节点 选择要查看其指标的节点，可以轻松地在副本之间切换。
然后可以看到每个副本的指标，如下所示
副本 0
副本 1
13. 高级 Base Command Platform 概念
本章介绍 Base Command Platform 的更高级功能。在本章中，您将了解特殊功能的深入用例，或以其他方式了解常用功能的深入属性。
13.1. 多节点作业
NVIDIA Base Command Platform 在集群中支持基于 MPI 的分布式多节点作业。这使您可以在多个节点上同时运行同一作业，但须满足以下要求。
必须使用节点中的所有 GPU。
容器镜像必须包含 OpenMPI 3.0+ 和 Horovod 等组件（如果需要）。
13.1.1. 定义多节点作业
对于多节点作业，NVIDIA Base Command Platform 调度（预留）所有由 --replicas 选项指定的节点。作业定义中指定的命令行仅在父节点（启动器）上执行，该父节点由副本 ID 0 标识。用户有责任通过使用 mpirun 命令在子节点（副本 ID >0）上执行命令，如本节中的示例所示。
NVIDIA Base Command Platform 提供所需的信息，主要是导出相关的 ENV 变量，以启用在所有副本上调用命令，并使用分布式 PyTorch 或 Horovod 启用多节点训练。
多节点作业命令行必须解决以下两个级别的节点间交互，才能成功完成多节点训练作业。
使用 mpirun 在副本（通常是全部）上调用命令。
将节点详细信息作为参数包含在分布式训练脚本中（例如父节点地址或主机文件）。
对于此需求，NVIDIA Base Command Platform 在作业容器运行时 shell 中设置以下变量。
环境变量 |
定义 |
|---|---|
NGC_ARRAY_INDEX |
设置为副本的索引。对于父节点，设置为 0。 |
NGC_ARRAY_SIZE |
设置为作业定义中的副本数。 |
NGC_MASTER_ADDR |
用于访问父节点或启动器的地址（DNS 服务）。在所有副本上设置。对于副本 0，它指向 localhost。 用于分布式训练（例如 PyTorch）。 |
NGC_REPLICA_ID |
与 NGC_ARRAY_INDEX 相同。 |
OMPI_MCA_orte_default_hostfile |
这仅在父节点或副本 0 上有效。 设置为主机文件位置，用于分布式训练（如 Horovod）。 |
13.1.2. 了解 –replicas 参数
下表显示了 --replicas 参数对应的节点计数和副本 ID。
–replicas |
节点数 |
副本 ID |
|---|---|---|
|
不适用 |
不适用 |
|
不适用 |
不适用 |
|
2 (1x 父节点，1x 子节点) |
0, 1 |
|
3 (1x 父节点，2x 子节点) |
0, 1, 2 |
|
4 (1x 父节点，3x 子节点) |
0, 1, 2, 3 |
|
N (1x 父节点，(N-1)x 子节点 |
0, 1, 2, …(N-1) |
13.1.3. 从 NGC Web UI 启动多节点作业
多节点作业也可以使用 NGC Web UI 启动和监控。
注意
为了使容器能够被选择用于多节点作业，必须首先在 Web UI 中将其标记为“多节点容器”。
私有注册表用户可以从容器页面标记容器：单击菜单图标，选择“编辑”，然后选中“多节点容器”复选框并保存更改。公共容器如果具有多节点能力，也必须由发布者进行相应标记。
登录到 NGC 仪表板，然后从左侧菜单中选择“作业”。
在右上角，选择 创建作业。
单击 创建多节点作业 选项卡。
在 加速计算环境 部分下，选择您的 ACE 和实例类型。
在 多节点 部分下，选择要使用的副本计数。
在 数据输入 部分下，根据需要选择数据集和工作区。
在 数据输出 部分下，输入结果挂载点。
在 容器选择 部分下，选择要运行的容器和标签、要在容器内运行的任何命令以及可选的容器端口。
在 启动作业 部分下，为作业提供名称并输入总运行时间。
单击 启动。
13.1.4. 从 NGC Web UI 查看多节点作业结果
从左侧菜单单击 作业。
选择要查看的作业。
选择选项卡之一 - 概览、遥测、状态历史记录、结果 或 日志。以下示例显示“状态历史记录”。您可以查看整体作业或每个单独副本的历史记录。
13.1.5. 使用 NGC CLI 启动多节点作业
除了运行作业所需的其他参数外，以下是运行多节点作业所需的参数。
语法
$ ngc base-command run \
...
--replicas <num>
--total-runtime <t>
--preempt RUNONCE
...
其中
--replicas：指定运行多节点并行作业的节点数（包括主节点）。
--total-runtime：指定作业在正常关闭之前可以运行的总时间。格式：[nD] [nH] [nM] [nS]。
注意
要查找特定 ACE 的最大运行时间，请使用以下命令
$ ngc ace info <ace name> --org <org id> --format_type json
输出中的 “maxRuntimeSeconds” 字段包含最大运行时间。
--preempt RUNONCE：为抢占和调度指定 RUNONCE 作业类。
示例 1：在节点 0 上运行 Jupyterlab 实例
$ ngc base-command run \
--name "multinode-jupyterlab" \
--total-runtime 3000s \
--instance dgxa100.80g.8.norm \
--array-type "MPI" \
--replicas "2" \
--image "nvidia/tensorflow:21.03-tf1-py3" \
--result /result \
--port 8888 \
--commandline "set -x && date && nvidia-smi && \
jupyter lab --ip=0.0.0.0 --allow-root --no-browser --NotebookApp.token='' --notebook-dir=/ --NotebookApp.allow_origin=*"
mpirun 和 bcprun 命令然后可以在启动后从 Jupyterlab 中运行。
示例 2：使用 mpirun
$ ngc base-command run \
--name "multinode-simple-test" \
--total-runtime 3000s \
--instance dgxa100.80g.8.norm \
--array-type "MPI" \
--replicas "2" \
--image "nvidia/tensorflow:21.03-tf1-py3" \
--result /result \
--port 8888 \
--commandline "mpirun --allow-run-as-root -x IBV_DRIVERS=/usr/lib/libibverbs/libmlx5 -np \${NGC_ARRAY_SIZE} -npernode 1 bash -c 'hostname'"
请注意，mpirun 用于在所有副本上执行命令，通过 NGC_ARRAY_SIZE 指定。要在每个副本上运行的实际命令（在示例中以不同颜色突出显示）作为 bash 命令输入包含（特殊字符根据需要转义）。
示例 3： 将 mpirun 与 PyTorch 结合使用
请注意 NGC_ARRAY_SIZE、NGC_ARRAY_INDEX 和 NGC_MASTER_ADDR 的使用。
$ ngc base-command run \
--name "multinode-pytorch" \
--total-runtime 3000s \
--instance dgxa100.80g.8.norm \
--array-type "MPI" \
--replicas "2" \
--image "nvidia/pytorch:22.11-py3" \
--result /result \
--port 8888 \
--commandline "python3 -m torch.distributed.launch \
--nproc_per_node=8 \
--nnodes=\${NGC_ARRAY_SIZE} \
--node_rank=\${NGC_ARRAY_INDEX} \
--master_addr=\${NGC_MASTER_ADDR} train.py"
13.1.5.1. 将命令定向到特定副本
CLI 可用于通过使用以下命令在正在运行的作业容器中执行命令。
$ ngc base-command exec <job_id>
对于多节点工作负载，有多个副本正在运行容器。副本使用从零开始的索引编号。上述命令仅指定作业 ID，将 exec 命令定向到第一个副本，该副本的索引为 0（零）。您可能需要在多节点工作负载中的不同副本上运行命令，这可以通过以下选项实现。
$ ngc base-command exec <job_id>:<replica-id>
省略时，第一个副本（ID 0）将成为命令的目标。
13.1.5.2. 查看多节点作业状态和信息
可以使用以下命令检查整体作业的状态
$ ngc base-command info <job_id>
要检查其中一个副本的状态，请发出
$ ngc base-command info <job_id>:<replica_id>
where <replica_id > is from 0 (zero) to (number of replicas)-1.
以下示例显示了两个副本作业的每个副本的状态
$ ngc base-command info 1070707:0
--------------------------------------------------
Replica Information
Replica: 1070707:0
Created At: 2020-03-04 22:39:00 UTC
Submitted By: John Smith
Team: swngc-mnpilot
Replica Status
Status: CREATED
--------------------------------------------------
$ ngc base-command info 1070707:1
--------------------------------------------------
Replica Information
Replica: 1070707:1
Created At: 2020-03-04 22:39:00 UTC
Submitted By: John Smith
Team: swngc-mnpilot
Replica Status
Status: CREATED
--------------------------------------------------
要获取有关每个副本结果的信息，请使用
$ ngc result info <job_id>:<replica_id>
13.1.6. 使用 bcprun 启动多节点作业
在启动多节点作业时，NGC 在 Base Command Platform 集群上安装 bcprun，这是一个多节点应用程序启动器实用程序。bcprun 的主要优点如下
消除了容器镜像中对
mpirun的依赖。提供与
srun等效的功能，允许用户轻松地在 Slurm 和 Base Command Platform 集群之间迁移作业。提供统一的启动机制，通过抽象分布式 DL 应用程序所需的特定于框架的环境。
允许用户提交命令作为批处理脚本的一部分。
语法
$ bcprun --cmd '<command-line>'
其中
<command-line>是要运行的命令
示例:
$ bcprun --cmd 'python train.py'
可选参数
|
要运行的节点数。（类型：整数） 范围：最小值：1，最大值：R， 其中 R 是 NGC 作业请求的最大副本数。 默认值：R 示例： |
|
每个节点要运行的任务数。（类型：整数） 范围：最小值：1，最大值：（无） 默认值：环境变量 示例： |
|
要设置的环境变量，格式为 ‘key=value’。 （类型：字符串） 每个变量赋值都需要单独的 默认值：（无） 示例： |
|
从中运行 <cmd> 的基本目录。（类型：字符串） 可以包含使用 默认值：环境变量 PWD（当前工作目录） 示例: --workdir '$WORK_HOME/scripts' --env
'WORK_HOME=/mnt/workspace'
|
|
使用外部启动器程序运行 <cmd>。（类型：字符串） 支持的启动器：mpirun、horovodrun
注意：此选项假定启动器存在且位于 PATH 中。 启动器特定的参数（不是 bcprun 选项的一部分）可以作为后缀提供。 示例： 默认值：（无） |
|
启用异步故障支持运行，即 bcprun 的子进程可以在失败时退出，而不会停止程序。 当至少有一个子进程正在运行时，程序将继续运行。 bcprun 的默认语义是当 bcprun 启动的任何子进程以错误退出时停止程序。 |
|
打印调试信息并启用详细模式。 此选项还设置以下环境变量以获取额外的调试日志 NCCL_DEBUG=INFO TORCH_DISTRIBUTED_DEBUG=INFO |
|
注意：对于数组类型为 “PYTORCH” 的作业。 覆盖用于保存作业日志的默认位置。此位置将包含每个工作节点的 必须同时启用 示例： |
|
使用此标志时，bcprun 会将日志打印到终端 stdout/stderr，而不是重定向到 joblog.log 和每个 rank 每个节点的文件。 |
|
注意：对于数组类型为 “PYTORCH” 的作业。 使用此标志时，除了日志外，bcprun 还会使用 fluent-bit 的 json 包装器打印带有时间戳和文件名的日志。 不使用此标志时，它将写入原始输出。此标志仅在进程 stdout/stderr 被重定向到日志时适用。 |
|
打印版本信息。 |
|
打印此帮助消息。 |
13.1.6.1. 基本用法
以下多节点作业提交命令使用 bcprun 在两个节点上运行 hostname 命令。
ngc base-command run --name "getting-started" \
--image "nvidia/pytorch:20.06-py3" --commandline "bcprun --cmd hostname" \
--preempt RUNONCE --result /result --ace nv-us-west-2 --org nvidian \
--team swngc-mnpilot --instance dgx1v.32g.8.norm --total-runtime 1m \
--replicas 2 --array-type MPI
该作业将打印每个副本的主机名，并且输出将类似于以下内容。
1174493-worker-0
1174493-worker-1
bcprun仅在 Base Command Platform 集群中运行的容器内可用。因此，bcprun命令及其参数只能作为 ngc 作业的--commandline参数的一部分指定（直接指定或在脚本中指定）多节点 ngc 作业必须指定
--array-type参数来定义容器内所需的环境。支持以下数组类型MPI：这是 ngc 作业的旧式数组类型，用于从单个启动器节点（又名 mpirun 启动模型）启动多节点应用程序
PYTORCH：这将设置环境，以便使用简单的命令启动分布式 PyTorch 应用程序。示例：
bcprun --npernode 8 --cmd 'python train.py'
bcprun要求用户应用程序命令（及其参数）作为标志--cmd（或简写形式 -c）的字符串参数指定
13.1.6.2. 使用 --nnodes / -n
此选项指定要在多少个节点上启动命令。虽然分配给 ngc 作业的最大节点数由 --replicas 指定，但用户可以使用 --nnodes（或简写形式 -n）在节点子集上启动应用程序。在没有此选项的情况下，bcprun 的默认行为是在所有副本节点上启动命令。
ngc base-command run --name "getting-started" --image "nvidia/pytorch:20.06-py3" \
--commandline "bcprun --nnodes 3 --cmd hostname"--preempt RUNONCE --result /result \
--ace nv-us-west-2 --org nvidian --team swngc-mnpilot --instance dgx1v.32g.8.norm \
--total-runtime 1m --replicas 4 --array-type MPI
例如，尽管分配了四个副本，但 bcprun 将仅在 3 个节点上运行 hostname 并产生以下输出。
1174495-worker-0
1174495-worker-1
1174495-worker-2
13.1.6.3. 使用 --npernode / -p
可以通过指定 --npernode（或简写形式 -p）选项在每个节点上运行应用程序任务的多个实例，如下所示
ngc base-command run --name "getting-started" --image "nvidia/pytorch:20.06-py3" \
--commandline "bcprun --npernode 2 --cmd hostname"--preempt RUNONCE --result /result \
--ace nv-us-west-2 --org nvidian --team swngc-mnpilot --instance dgx1v.32g.8.norm \
--total-runtime 1m --replicas 2 --array-type MPI
在这种情况下，hostname 的两个实例在每个节点上运行，这将产生以下输出
1174497-worker-0
1174497-worker-0
1174497-worker-1
1174497-worker-1
13.1.6.4. 使用 --workdir / -w
用户可以使用 --workdir 选项（或简写形式 -w）指定可执行文件的路径。此示例显示了在 2 个节点上，每个节点 8 个 GPU 的 PyTorch DDP 模型训练作业中使用 bcprun 的情况；并说明了 --workdir 选项的用法
ngc base-command run --name "pytorch-job" --image "nvidia/pytorch:21.10-py3" \
--commandline "bcprun --npernode 8 --cmd 'python train.py' --workdir /workspace/test" \
--workspace MLumas39SZmqY8z2NAqoHw:/workspace/test:RW --result /result --preempt RUNONCE \
--ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm --replicas 2 --array-type "PYTORCH" \
--total-runtime 30m
13.1.6.5. 使用 --env / -e
用户可以设置环境变量，这些环境变量可以传递给 rank 进程，并由使用 --env 选项（或简写形式 -e）启动的命令使用。以下示例显示用户能够将 NCCL 输出的调试级别设置为 INFO。
ngc base-command run --name "pytorch-job" --image "nvidia/pytorch:21.10-py3" \
--commandline "bcprun --npernode 8 --cmd 'python train.py' --workdir /workspace/test \
--env NCCL_DEBUG=INFO" --workspace MLumas39SZmqY8z2NAqoHw:/workspace/test:RW \
--result /result --preempt RUNONCE --ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm \
--replicas 2 --array-type "PYTORCH" --total-runtime 30m
13.1.6.6. 在脚本中使用 bcprun
bcprun 命令可以链接到批处理脚本中，并通过作业命令行调用，如下所示。
ngc base-command run --name "pytorch-job" --image "nvidia/pytorch:21.10-py3" \
--commandline "bcprun.sub" --workspace MLumas39SZmqY8z2NAqoHw:/workspace/test:RW \
--result /result --preempt RUNONCE --ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm \
--replicas 2 --array-type "PYTORCH" --total-runtime 30m
其中 bcprun.sub 是一个可执行脚本，其中包含许多 bcprun 命令，如下所示
#!/bin/bash
bcprun --npernode 8 --cmd "python train.py --phase=1"
bcprun --npernode 8 --cmd "python train.py --phase=2"
13.1.6.7. PyTorch 示例
bcprun 通过自动抽象 torch.distributed 所需的环境，大大简化了在 BCP 集群上启动分布式 PyTorch 应用程序的过程。可以使用 mpirun 启动使用 python 训练脚本 (train.py) 的多节点 PyTorch 分布式数据并行 (DDP) 训练作业，如下所示
mpirun -np 2 -npernode 1 python -m torch.distributed.launch --nproc_per_node=8 \
--nnodes=${NGC_ARRAY_SIZE} --node_rank=${NGC_ARRAY_INDEX} --master_addr=${NGC_MASTER_ADDR} train.py
相比之下，使用 bcprun 的命令看起来像这样
bcprun -p 8 -c 'python train.py'
使用 bcprun，我们有两个优势
容器不依赖于 MPI 或 mpirun
分布式 PyTorch 特定的参数现在被抽象到一个统一的启动机制中
结合 --array-type PYTORCH ngc 作业参数，完整的作业规范如下所示
ngc base-command run --name "pytorch-test" --image "nvidia/pytorch:21.10-py3" \
--commandline "bcprun -d -p 8 -c 'python train.py' -w /workspace/test" \
--workspace MLumas39SZmqY8z2NAqoHw:/workspace/test:RW --result /result --preempt RUNONCE \
--ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm --replicas 2 --array-type "PYTORCH" \
--total-runtime 30m
环境变量
NGC 作业参数 --array-type PYTORCH 由 bcprun 用于设置 PyTorch 训练 rank 进程所需的环境变量，并符合 torch.distributed 的要求。当启动训练脚本时，PyTorch 分布式应用程序可以依赖于由 bcprun 设置的以下环境变量
LOCAL_RANK |
RANK |
GROUP_RANK |
LOCAL_WORLD_SIZE |
WORLD_SIZE |
ROLE_WORLD_SIZE |
MASTER_ADDR |
MASTER_PORT |
NGC_RESULT_DIR |
可选地，如果在 bcprun 命令中启用了 -d, --debug 参数，则将设置以下环境变量
NCCL_DEBUG=INFO |
TORCH_DISTRIBUTED_DEBUG=INFO |
PyTorch 本地 rank: ‘--local-rank’ 标志 vs ‘LOCAL_RANK’ 环境变量
bcprun 始终设置环境变量 LOCAL_RANK，而与 PyTorch 版本无关。
bcprun 在此版本中还默认传递 --local-rank 标志参数。
从 PyTorch 版本 >= 1.9 开始，--local-rank 标志已被弃用。训练脚本应改为使用环境变量 LOCAL_RANK。
bcprun 将仅为 PyTorch 版本 < 1.10 传递标志参数 --local-rank。对于所有 PyTorch 版本 >= 1.10，默认情况下，--local-rank 标志参数将 *不* 传递给训练脚本。如果您依赖于在 PyTorch 版本 >= 1.10 的训练脚本中解析 --local-rank，则可以通过设置环境变量 NGC_PYTORCH_USE_ENV=0 来覆盖默认行为。相反，对于 PyTorch 版本 < 1.10，设置环境变量 NGC_PYTORCH_USE_ENV=1 将禁止传递 --local-rank 标志参数。
13.1.6.8. BERT 示例
以下示例说明了使用 bcprun 运行 PyTorch BERT 模型的训练作业。
ngc base-command run --name "bert_example" --image "nvidia/dlx_bert:21.05-py3" \
--commandline "cd /workspace/bert && BATCHSIZE=\$(expr 8192 / \$NGC_ARRAY_SIZE) LR=6e-3 GRADIENT_STEPS=\$(expr 128 / \$NGC_ARRAY_SIZE) PHASE=1 NGC_NTASKS_PER_NODE=8 ./bcprun.sub && BATCHSIZE=\$(expr 4096 / \$NGC_ARRAY_SIZE) LR=4e-3 GRADIENT_STEPS=\$(expr 256 / \$NGC_ARRAY_SIZE) PHASE=2 NGC_NTASKS_PER_NODE=8 ./bcprun.sub" \
--workspace MLumas39SZmqY8z2NAqoHw:/workspace/bert:RW --datasetid 208137:/workspace/data \
--result /result --preempt RUNONCE --ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm \
--replicas 2 --array-type "PYTORCH" --total-runtime 2D
13.1.6.9. SSD 示例
ngc base-command run --name "SSD_example" --image "nvidia/dlx_ssd:latest" \
--commandline "cd /workspace/ssd; ./ssd_bcprun.sub" --workspace SSD_dev6:/workspace/ssd:RW \
--result /result --preempt RUNONCE --ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm \
--replicas 2 --array-type "PYTORCH" --total-runtime 10h
13.1.6.10. PyTorch Lightning 示例
下面显示了 PyTorch Lightning 训练作业的示例。请注意，数组类型 PYTORCH 用于 PTL 作业。
ngc base-command run --name "ptl-test" --image "nvidia/nemo_megatron:pyt21.10" \
--commandline "bcprun -p 8 -d -c 'python test_mnist_ddp.py'" \
--workspace MLumas39SZmqY8z2NAqoHw:/workspace/bert:RW --result /result --preempt RUNONCE \
--ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm --replicas 2 --array-type "PYTORCH" \
--total-runtime 30m
注意：bcprun 设置环境变量（“RANK”、“GROUP_RANK”、“LOCAL_RANK”、“LOCAL_WORLD_SIZE”），这允许 PyTorch Lightning 推断 torchelastic 环境。
13.1.6.11. MPI 示例
对于需要 MPI 和 mpirun 的应用程序，bcprun 允许通过定义 --launcher="mpirun" 选项来实现此类应用程序。以下是使用 bcprun 的 MPI 多节点作业的示例。
ngc base-command run --name "bcprun-launcher-mpirun" --image "nvidia/mn-nccl-test:sharp" \
--commandline "bcprun -l mpirun -p 8 -c 'all_reduce_perf -b 1G -e 1G -g 1 -c 0 -n 200'" \
--result /result --preempt RUNONCE --ace netapp-sjc-4-ngc-dev6 --instance dgxa100.40g.8.norm \
--replicas 2 --array-type "MPI" --total-runtime 30m
此处的数组类型设置为 “MPI”。bcprun 使用定义的 mpirun 启动器调用多节点作业。bcprun 调用的等效 mpirun 命令如下所示。
mpirun --allow-run-as-root -np 16 -npernode 8 all_reduce_perf -b 1G -e 1G -g 1 -c 0 -n 200
13.2. 作业 ENTRYPOINT
NGC Base Command Platform CLI 现在提供了在运行作业时合并 Docker ENTRYPOINT 的选项。
一些 NVIDIA 深度学习框架容器依赖 ENTRYPOINT 来实现完整的功能。这些容器中的以下功能依赖于 ENTRYPOINT
要打印到日志的版本标语
任何平台先决条件缺失时的警告/错误
多节点的 MPI 设置
以下是在使用 docker run 命令通过合并的 ENTRYPOINT 运行 TensorFlow 容器后返回的版本标头信息的示例。
$ docker run --runtime=nvidia --rm -it nvcr.io/nvidia/tensorflow:21.03-tf1 nvidia-smi
================
== TensorFlow ==
================
NVIDIA Release 21.03-tf1 (build 20726338)
TensorFlow Version 1.15.5
Container image Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
Copyright 2017-2021 The TensorFlow Authors. All rights reserved.
NVIDIA Deep Learning Profiler (dlprof) Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
Various files include modifications (c) NVIDIA CORPORATION. All rights reserved.
This container image and its contents are governed by the NVIDIA Deep Learning Container License.
By pulling and using the container, you accept the terms and conditions of this license:
https://developer.nvidia.com/ngc/nvidia-deep-learning-container-license
NOTE: Legacy NVIDIA Driver detected. Compatibility mode ENABLED.
如果在 CLI 中不使用 ENTRYPOINT，则输出中不会有标语信息。
以下示例显示了使用 NGC Base Command CLI 在不使用 ENTRYPOINT 的情况下在 TensorFlow 容器中运行 nvidia-smi 的情况。
$ ngc base-command run \
--name "TensorFlow Demo" \
--preempt RUNONCE \
--min-timeslice 0s \
--total-runtime 0s \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--result /result \
--image "nvidia/tensorflow:21.03-tf1-py3" \
--commandline "nvidia-smi"
输出日志文件的初始行（未生成 TensorFlow 标头信息）
Thu Apr 15 17:32:02 2021
+-------------------------------------------------------------------+
| NVIDIA-SMI 450.80.02 Driver Version: 450.80.02 CUDA Version: 11.2 |
|---------------------+----------------------+----------------------+
...
13.2.1. 使用容器 ENTRYPOINT 的示例
要使用容器 ENTRYPOINT，请使用 --use-image-entrypoint 参数。
示例:
$ ngc base-command run \
--name "TensorFlow Entrypoint Demo" \
--preempt RUNONCE \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--result /result \
--image "nvidia/tensorflow:21.03-tf1-py3" \
--use-image-entrypoint \
--commandline "nvidia-smi"
带有 TensorFlow 标头信息的输出日志文件，包括 nvidia-smi 输出的初始行。
================
== TensorFlow ==
================
NVIDIA Release 21.03-tf1 (build 20726338)
TensorFlow Version 1.15.5
Container image Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
Copyright 2017-2021 The TensorFlow Authors. All rights reserved.
NVIDIA Deep Learning Profiler (dlprof) Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
Various files include modifications (c) NVIDIA CORPORATION. All rights reserved.
This container image and its contents are governed by the NVIDIA Deep Learning Container License.
By pulling and using the container, you accept the terms and conditions of this license:
https://developer.nvidia.com/ngc/nvidia-deep-learning-container-license
NOTE: Legacy NVIDIA Driver detected. Compatibility mode ENABLED.
Thu Apr 15 17:42:37 2021
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.80.02 Driver Version: 450.80.02 CUDA Version: 11.2 |
|-------------------------------+----------------------+----------------------+
...
13.2.2. 使用 CLI ENTRYPOINT 的示例
您还可以使用 --entrypoint 参数来指定要使用的 ENTRYPOINT，这将覆盖容器 ENTRYPOINT。
以下是在 NGC base-command 命令中指定 ENTRYPOINT 以运行 nvidia-smi 的示例。这取代了使用 --commandline 参数。
$ ngc base-command run \
--name "TensorFlow CLI Entrypoint Demo" \
--preempt RUNONCE \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--result /result \
--image "nvidia/tensorflow:21.03-tf1-py3" \
--entrypoint "nvidia-smi"
输出文件的初始行。
Thu Apr 15 17:52:53 2021
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.80.02 Driver Version: 450.80.02 CUDA Version: 11.0 |
|-------------------------------+----------------------+----------------------+
.. .
14. 教程
本章介绍了展示 Base Command Platform (BCP) 各项功能的教程。在本章中，您将了解产品内可用的即用型教程，用于学习工作流程或用作自定义工作流程的基础。本节还介绍了包含示例命令或模板的教程，这些教程可以用作新用户或新的复杂工作流程的起点。
注意
即用型教程作为 nvbc-tutorials 团队上下文中的模板以及所需的容器镜像和数据实体交付。您的组织管理员必须明确将您添加到该团队，您才能访问这些模板并基于这些模板运行工作负载。
14.1. 从现有模板启动作业
单击左侧导航菜单中的 BASE COMMAND > 作业，然后单击 创建作业。
单击 模板 选项卡。
单击要使用的模板的菜单图标，然后选择 应用模板。
创建作业页面打开，其中字段填充了作业模板的信息。
验证预填充的字段，输入唯一的名称，然后单击 启动。
14.2. 使用 JupyterLab 启动交互式作业
从现有模板中，您可以运行 nvbc-jupyterlab 模板来预填充作业创建字段，并使用 jupyterLab 启动交互式作业。以下是同一作业脚本模板的 CLI 脚本示例。
$ ngc base-command run \
--name "NVbc-jupyterlab" \
--preempt RUNONCE \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--commandline “set -x; jupyter lab --NotebookApp.token='' --notebook-dir=/
--NotebookApp.allow_origin='*' & date; nvidia-smi; echo $NVIDIA_BUILD_ID; sleep
1d”
--result /result \
--image "nvidia/pytorch:21.02-py3" \
--org nv-eagledemo \
--team nvbc-tutorials \
--port 8888
14.3. 使用 JupyterLab 启动多节点交互式作业
从现有模板中，您可以运行 nvbc-jupyterlab-mn 模板来预填充作业创建字段，并使用 2 个节点启动多节点交互式作业。以下是同一作业脚本模板的 CLI 脚本示例。
$ ngc base-command run \
--name "nvbc-jupyterlab-mn" \
--preempt RUNONCE \
--min-timeslice 0s
--total-runtime 36000s
--ace nv-eagledemo-ace \
--instance dgxa100.40g.8.norm \
--commandline “mpirun --allow-run-as-root -np 2 -npernode 1 bash -c ' set -x;
jupyter lab --NotebookApp.token='' --notebook-dir=/
--NotebookApp.allow_origin='*' & date; nvidia-smi; echo ; sleep
1d'”
--result /result \
--array-type "MPI"
--replicas "2"
--image "nvidia/pytorch:21.02-py3" \
--org nv-eagledemo \
--team nvbc-tutorials \
--port 8888
14.4. Tensorboard 入门
Tensorboard 默认已安装在标准 NGC 容器上。执行以下操作开始使用 TensorBoard
启动 TensorFlow 作业。
以下是使用 NGC CLI 的示例。
$ ngc base-command run \ --name "NVbc-tensorboard" \ --preempt RUNONCE \ --ace nv-eagledemo-ace \ --instance dgxa100.40g.1.norm \ --commandline "set -x; jupyter lab --allow-root --NotebookApp.token='' --NotebookApp.allow_origin=* --notebook-dir=/ & date; tensorboard --logdir /workspace/logs/fit ; sleep 1d" \ --result /result \ --image "nvidia/tensorflow:21.08-tf1-py3" \ --org nv-eagledemo \ --team nvbc-tutorials \ --port 8888 \ --port 6006
容器运行后，信息页面 URL 将映射到端口 8888 和 6006。
通过 JupyterLab 登录到容器并打开终端。
下载 TensorBoard 教程 notebook。
wget https://storage.googleapis.com/tensorflow_docs/tensorboard/docs/get_started.ipynb
打开下载的 notebook。
运行 notebook 中的命令，直到命令 6。
tensorboard --logdir logs/fit
打开映射到容器上端口 6006 的 URL 以打开 Tensorboard。
TensorBoard UI 应类似于以下示例。
有关如何使用 Tensorboard 的更多信息，请参阅 https://tensorflowcn.cn/tensorboard/get_started。
14.5. NCCL 测试
NCCL 测试检查 NCCL 操作的性能和正确性，您可以使用 nvbc-MN-NCCL-Tests 模板测试 GPU 之间的性能。以下是同一 NCCL 测试模板的 CLI 脚本示例。成功的 NCCL 测试的平均总线带宽预计 > 175GB。
$ ngc base-command run \
--name "nvbc-MN-NCCL-Tests" \
--preempt RUNONCE \
--total-runtime 86400s \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.1.norm \
--commandline “bash -c 'for i in {1..20}; do echo \"******************** Run
********************\"; mpirun -np ${NGC_ARRAY_SIZE} -npernode 1
/nccl-tests/build/all_reduce_perf -b 128M -e 2G -f 2 -t 8 -g 1;
done'”
--result /result \
--array-type “MPI” \
--replicas “2” \
--image "nv-eagledemo/mn-nccl-test:ibeagle" \
--org nv-eagledemo \
--team nvbc-tutorials
14.6. StyleGAN 单节点工作负载
从现有模板中，您可以运行 nvbc-stylegan-singlenode 模板来预填充作业创建字段并启动。以下是具有 8 个 GPU 的 StyleGAN 单节点工作负载的 CLI 脚本示例。
$ ngc base-command run \
--name "StyleGAN-singlenode" \
--preempt RUNONCE \
--min-timeslice 0s \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.8.norm \
--commandline “python -u -m torch.distributed.launch --nproc_per_node=8
/mnt/workspace/train.py --snap=25 --data=/dataset --batch-size=32
--lr=0.002”
--result /output \
--image "nv-eagledemo/nvbc-tutorials/pytorch_stylegan:v1" \
--org nv-eagledemo \
--team nvbc-tutorials \
--datasetid 76731:/dataset
以下是作业启动后遥测的示例。
14.7. StyleGAN 多节点工作负载
从现有模板中，您可以运行 nvbc-stylegan-multinode 模板来预填充作业创建字段并启动。以下是具有 2 个节点的多节点 StyleGAN 工作负载的 CLI 脚本示例。
$ ngc base-command run \
--name "StyleGAN-multinode" \
--preempt RUNONCE \
--min-timeslice 0s \
--total-runtime 230400s \
--ace nv-eagledemo-ace \
--instance dgxa100.40g.8.norm \
--commandline “mpirun --allow-run-as-root -np 2 -npernode 1 bash -c 'python
-u -m torch.distributed.launch --nproc_per_node=8
--master_addr=${NGC_MASTER_ADDR} --nnodes=${NGC_ARRAY_SIZE}
--node_rank=${NGC_ARRAY_INDEX} /mnt/workspace/train.py --snap=25 --data=/dataset
--batch-size=64 --lr=0.002'”
--result /output \
--array-type “MPI” \
--replicas “2” \
--image "nv-eagledemo/nvbc-tutorials/pytorch_stylegan3:pytorch.stylegan.v1"
\
--org nv-eagledemo \
--team nvbc-tutorials \
--datasetid 76731:/dataset
以下是作业启动后遥测的示例。
14.8. 从 S3 云存储构建数据集
本节详细介绍了使用 CLI 和代码从云存储桶构建数据集的示例。
开始之前执行以下操作。
确定云存储桶的凭据和位置。
了解存储桶内的目录结构。
在 Base Command Platform 中创建工作区（通常专用作主工作区）。
有关说明，请参阅 使用 Base Command Platform CLI 创建工作区。
运行当前作业以 exec 进入或从中运行以下示例。
14.8.1. 运行作业
启动 Jupyter notebook 作业。
替换 ACE、org、workspace 和 team 值参数。作业将运行一小时。
ngc base-command run --name "demo-s3-cli" --preempt RUNONCE --ace {ace-name} \ --instance {instance-type} --commandline "jupyter lab --ip=0.0.0.0 --allow-root \ --no-browser --NotebookApp.token='' \ --notebook-dir=/ --NotebookApp.allow_origin='*' & date; sleep 1h" --result /results \ --workspace {workspace-name}:/{workspace-name}:RW --image "nvidia/pytorch:21.07-py3" \ --org {org-name} --team {team-name} --port 8888
作业启动后，访问 JupyterLab 终端。
ngc base-command info {id} -------------------------------------------------- Job Information Id: 2233490 ... Job Container Information Docker Image URL: nvidia/pytorch:21.07-py3 Port Mappings Container port: 8888 mapped to https://tnmy3490.eagle-demo.proxy.ace.ngc.nvidia.com ... Job Status ... Status: RUNNING Status Type: OK --------------------------------------------------
或者，通过 NGC CLI exec 进入作业。
14.8.2. 使用 AWS CLI 创建数据集
获取、解压缩并安装 AWS CLI zip 文件。
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" unzip awscliv2.zip ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
确保可以访问 AWS CLI。
aws --version
通过输入访问密钥 ID 和秘密访问密钥来完成 AWS 配置。
这些可以在 AWS 的 IAM 用户面板下找到。有关更多信息，请参阅 AWS CLI 文档。
aws configure AWS Access Key ID [None]: <ACCESS_KEY> AWS Secret Access Key [None]: <SECRET_ACCESS_KEY> Default region name [None]: us-west-2 Default output format [None]: json
将存储桶同步到结果文件夹以保存为数据集。
aws s3 sync 's3://<source-bucket>' '../results'
结果现在应该可以保存为数据集了。有关更多信息，请参阅 管理数据集。
14.8.3. 使用 AWS Boto3 创建数据集
Boto3 是用于访问 S3 存储桶的 AWS SDK。本节将介绍从 S3 存储桶下载特定文件，然后将其保存到结果文件夹。查看更多关于 Boto3 的文档。
通过 pip 安装 Boto3，并在 Jupyter notebook 的第一个单元格中准备导入。
!pip installboto3 import boto3 import io import os
使用 AWS 访问密钥和秘密访问密钥初始化 Boto3。
确保 IAM 用户设置对所需的 S3 存储桶具有适当的访问权限和许可。
# Let's use Amazon S3 by initializing our Access Key and Secret Access Key s3 = boto3.resource('s3', aws_access_key_id=<ACCESS_KEY>, aws_secret_access_key=<SECRET_ACCESS_KEY>) bucket = s3.Bucket(<BUCKET_NAME>)
14.8.4. 下载文件
下载文件是 Boto3 中内置的功能。它将需要存储桶名称、对象名称（称为键）和文件输出名称。有关更多信息，请参阅 Amazon S3 示例 - 下载文件。
s3.download_file(<BUCKET_NAME>, <OBJECT_NAME>, <FILE_NAME>)
14.8.5. 下载文件夹
以下包含一个函数，用于将 S3 存储桶中的单目录深度下载到 BCP 存储，可以是作业的 /results 挂载点，也可以是作业中挂载的 Base Command Platform 工作区。
def download_s3_folder(s3_folder, local_dir='../results/s3_bucket'):
for obj in bucket.objects.filter(Prefix=s3_folder):
target = obj.key if local_dir is None \
else os.path.join(local_dir, os.path.relpath(obj.key, s3_folder))
if not os.path.exists(os.path.dirname(target)):
os.makedirs(os.path.dirname(target))
if obj.key[-1] == '/':
continue
print(obj.key)
bucket.download_file(obj.key, target)
要从 /results 挂载点保存数据集或检查点，请下载内容，然后按照 将检查点转换为数据集 中的描述上传为数据集。
14.9. 使用数据加载器进行云存储
本文档详细介绍了使用云存储桶中的数据加载器的示例。建议在继续使用数据加载器之前尝试 CLI 选项，因为它不会保存文件夹层次结构。
开始之前执行以下操作。
确定云存储桶的凭据和位置。
了解存储桶内的目录结构。
在 Base Command Platform 中创建工作区（通常专用作主工作区）。
有关说明，请参阅 使用 Base Command Platform CLI 创建工作区。
14.9.1. 运行和打开 JupyterLab
在作业中挂载工作区。
替换 ACE、org、workspace 和 team 参数。
ngc base-command run --name "demo-s3-dataloader" --preempt RUNONCE --ace {ace-name} \ --instance {instance-type} --commandline "jupyter lab --ip=0.0.0.0 \ --allow-root --no-browser --NotebookApp.token='' --notebook-dir=/ \ --NotebookApp.allow_origin='*' & date; sleep 6h" --result /results \ --workspace {workspace-name}:/mount/{workspace-name}:RW --image "nvidia/pytorch:21.07-py3" \ --org {org-name} --team {team-name} --port 8888
打开 JupyterLab 的链接以访问 UI。
通过使用 batch info 命令获取作业的信息来执行此操作。以下是带有映射端口的响应示例。您可以按住 ctrl 键并单击粗体链接以在浏览器中访问它。
ngc base-command info {id} -------------------------------------------------- Job Information Id: 2233490 ... Job Container Information Docker Image URL: nvidia/pytorch:21.07-py3 Port Mappings Container port: 8888 mapped to https://tnmy3490.eagle-demo.proxy.ace.ngc.nvidia.com ... Job Status ... Status: RUNNING Status Type: OK --------------------------------------------------
您现在应该看到创建文件的选项提示。
导航到侧边栏上的工作区，然后单击 Python 3 以创建文件。
14.9.2. 利用云数据加载器进行训练
使用代码创建 Jupyter Notebook，进行以下更改
不要发出
import wandb。添加以下导入
# Imports !pip install boto3 import boto3 from botocore import UNSIGNED from bot ocore.config import Config更改 #3.2 的第一行。
从这里
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
到这里
s3 = boto3.client('s3', config=Config(signature_version=UNSIGNED)) bucket_name='mnist-testbucket' key='mnist_2.npz' s3_response_object = s3.get_object(Bucket=bucket_name, Key=key) object_content = s3_response_object['Body'].read() load_bytes = BytesIO(object_content) with np.load(load_bytes, allow_pickle=True) as f: x_train, y_train = f['x_train'], f['y_train'] x_test, y_test = f['x_test'], f['y_test']
执行步骤 #3 到步骤 #6。
14.10. 使用 Visual Studio Code 启动交互式作业
本教程部分包含三个选项，用于安装和访问 Visual Studio Code 以与 Base Command Platform 一起使用
在容器中安装 Visual Studio Code 的 code-server
在作业运行时安装和运行 Visual Studio Code 的 code-server
在作业中安装 Visual Studio Code CLI 并启动远程隧道
14.10.1. 在容器中安装 Visual Studio Code
此选项详细介绍了在容器中安装 Visual Studio Code，将容器推送到私有注册表，然后在 Base Command Platform 中使用容器启动作业，以便可以使用 Web 浏览器访问 VS Code。
14.10.1.1. 构建容器
以下是用于创建容器的示例 Dockerfile，该容器可以启动 Visual Studio Code 以通过 Web 浏览器访问。它包括下载和安装扩展的示例。
要构建此容器，您需要一个设置了 Docker 和 NVIDIA Container Toolkit 的系统。有关更多信息，请参阅 NVIDIA Container Toolkit 文档。
有关更多信息，请参阅 code-server 文档。
为容器和我们需要安装的扩展创建 Dockerfile。下面提供了示例 Dockerfile。在本例中，我们从 NGC 的基本 TensorFlow 容器开始，但可以使用您选择的任何容器。
ARG FROM_IMAGE_NAME=nvcr.io/nvidia/tensorflow:22.04-tf2-py3 FROM ${FROM_IMAGE_NAME} # Install code-server to enable easy remote development on a container # More info about code-server be found here: https://coder.com/docs/code-server/v4.4.0 ADD https://github.com/coder/code-server/releases/download/v4.4.0/code-server_4.4.0_amd64.deb code-server_4.4.0_amd64.deb RUN dpkg -i ./code-server_4.4.0_amd64.deb && rm -f code-server_4.4.0_amd64.deb # Install extensions from the marketplace RUN code-server --install-extension ms-python.python # Can also download vsix files and install them locally ADD https://github.com/microsoft/vscode-cpptools/releases/download/v1.9.8/cpptools-linux.vsix cpptools-linux.vsix RUN code-server --install-extension cpptools-linux.vsix # Download vsix from: https://marketplace.visualstudio.com/items?itemName=NVIDIA.nsight-vscode-edition # https://marketplace.visualstudio.com/_apis/public/gallery/publishers/NVIDIA/vsextensions/nsight-vscode-edition/2022.1.31181613/vspackage COPY NVIDIA.nsight-vscode-edition-2022.1.31181613.vsix NVIDIA.nsight-vscode-edition.vsix RUN code-server --install-extension NVIDIA.nsight-vscode-edition.vsix
从包含 Dockerfile 的目录中，运行以下命令以构建容器并将其推送到相应的团队和组织。
docker build -t nvcr.io/<org>/<team>/vscode-server:22.04-tf2 . docker push nvcr.io/<org>/<team>/vscode-server:22.04-tf2
14.10.1.2. 启动作业
使用 Web UI 或 NGC CLI，然后可以使用容器运行作业。下面提供了示例作业命令。
此作业命令选择我们刚刚构建并推送到私有注册表的 VS Code 容器。它在 BCP 中提供与命令中的
--bind-addr参数对应的端口映射，并提供带有必要参数的启动命令以启动 VS Code。注意： 访问 VS Code 控制台的密码设置为commandline参数中的环境变量。此环境变量应设置为您选择的密码。ngc base-command run \ --name "run_vscode" \ --ace <ace>\ --org <org> \ --team <team> \ --instance dgxa100.40g.1.norm \ --image "nvcr.io/<org>/<team>/vscode:22.04-tf2" \ --port 8899 \ --result /results \ --total-runtime 1h \ --commandline "\ PASSWORD=mypass code-server --auth password --bind-addr 0.0.0.0:8899 /workspace & \ sleep infinity"
作业创建并运行后，打开 Base Command Platform 的 Web UI。在作业的“概述”页面中，单击映射到 code-server 端口的链接（在本例中为
8899）。然后在新窗口中，输入密码（在上面的示例中为
mypass）以进入 Visual Studio Code IDE。
VS Code 应该在密码提示后出现。它可能需要一些快速设置步骤，例如信任添加到 VS Code 的文件/目录、主题布局等。一旦 VS Code 启动并运行，您就可以编辑文件，并且由于已安装 Python 和 Cpp + Nsight 扩展，IntelliSense 也应该可以工作。
14.10.2. 在运行时添加 Visual Studio Code 功能
您还可以在启动现有镜像时在运行时安装和运行 Visual Studio Code。
以下示例显示了 NGC CLI 命令，用于将 Visual Studio Code 作为 Base Command 作业的 --commandline 参数安装和启动，使用 nvidia/pytorch 镜像。
ngc base-command run --image nvidia/pytorch:22.05-py3 --port 8899 \
--name "run_vscode" \
--ace <ace>\
--org <org> \
--team <team> \
--instance dgxa100.40g.1.norm \
--result /results \
--total-runtime 1h \
--commandline "wget -nc https://github.com/coder/code-server/releases/download/v4.4.0/code-server_4.4.0_amd64.deb -o code-server_4.4.0_amd64.deb && dpkg -i ./code-server_4.4.0_amd64.deb && PASSWORD=mypass code-server --auth password --bind-addr 0.0.0.0:8899"
14.10.3. 通过远程隧道设置和访问 Visual Studio Code
对于从已运行的 Base Command Platform 作业设置和访问 Visual Studio Code，此选项是最简单和最直接的选项，因为它不需要在作业运行时配置端口映射。
它利用 VS Code 的 远程隧道 功能，我们将 VS Code CLI 安装在作业的容器中，然后为 VS Code 创建到作业的远程隧道，可以通过 Web 浏览器或您自己的 VS Code 实例访问该隧道。
在作业中，运行以下命令以下载和提取 VS Code CLI。
curl -Lk 'https://vscode.js.cn/sha/download?build=stable&os=cli-alpine-x64' --output vscode_cli.tar.gz tar -xf vscode_cli.tar.gz您可以创建一个 Dockerfile 来构建您自己的已安装此功能的容器镜像，如第一个示例中所述，或者您可以在运行时安装此功能，如上一个示例中所述。
要在已运行的作业中安装此功能，您可以使用以下命令 exec 进入作业，然后运行上述命令。
$ ngc base-command exec <job_id>在容器和/或作业中安装 CLI 后，exec 进入作业，然后运行以下命令。按照提示进行身份验证，然后打开提供的链接以从浏览器访问 VS Code。
root@5517702:/job_workspace# ./code tunnel * Visual Studio Code Server By using the software, you agree to the Visual Studio Code Server License Terms (https://aka.ms/vscode-server-license) and the Microsoft Privacy Statement (https://privacy.microsoft.com/en-US/privacystatement). ✔ How would you like to log in to Visual Studio Code? · Microsoft Account To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code EM2SACRJT to authenticate. ✔ What would you like to call this machine? · BCP-5517702 [2023-11-28 17:29:46] info Creating tunnel with the name: bcp-5517702 Open this link in your browser https://vscode.dev/tunnel/bcp-5517702/job_workspace
14.11. 运行 DeepSpeed
DeepSpeed 是一个深度学习优化库，使分布式训练和推理变得简单、高效和有效。本节详细介绍了如何在 Base Command Platform 上启动 DeepSpeed 示例作业。
14.11.1. 创建 DeepSpeed 容器
以下是用于为特定版本的 DeepSpeed 创建容器镜像的示例 Dockerfile。NVIDIA PyTorch 容器镜像用作基本镜像，以提供 DeepSpeed 所需的 PyTorch 依赖项。
定义容器镜像
1# Example Dockerfile for building a DeepSpeed image 2ARG FROM_IMAGE_NAME=nvcr.io/nvidia/pytorch:23.12-py3 3FROM ${FROM_IMAGE_NAME} 4 5ENV TORCH_CUDA_ARCH_LIST="8.0 8.6 9.0+PTX" 6 7# libaio-dev required for async-io 8# https://deepspeed.org.cn/docs/config-json/#asynchronous-io 9RUN apt update && \ 10 apt install -y --no-install-recommends libaio-dev 11 12RUN pip install --upgrade pip setuptools wheel && \ 13 pip config set global.disable-pip-version-check true 14 15RUN cd /opt && \ 16 pip list | \ 17 awk '{print$1"=="$2}' | \ 18 tail +3 > pip_constraints.txt 19 20RUN pip install --upgrade pip && \ 21 pip install \ 22 triton \ 23 ninja \ 24 hjson \ 25 py-cpuinfo 26 27RUN python -m pip install --no-cache-dir -i https://pypi.anaconda.org/mpi4py/simple mpi4py 28 29RUN cd /opt && \ 30 git clone https://github.com/microsoft/DeepSpeed.git && \ 31 cd DeepSpeed && \ 32 git checkout v0.12.6 && \ 33 find . -type f -not -path '*/\.*' -exec \ 34 sed -i 's%std=c++14%std=c++17%g' {} + && \ 35 pip install pydantic==1.10.13 && \ 36 pip install -c /opt/pip_constraints.txt deepspeed-kernels && \ 37 DS_BUILD_OPS=1 DS_BUILD_SPARSE_ATTN=0 DS_BUILD_EVOFORMER_ATTN=0 \ 38 pip install -vvv --no-cache-dir --global-option="build_ext" .
根据需要构建然后推送容器镜像，使用您的 BCP 组织私有注册表标识符。例如
docker build -t nvcr.io/<your private org>/pytorch-deepspeed:0.12.6 -f Dockerfile .
在构建镜像并将其存储在您组织的私有注册表中之后，您将需要一个脚本来启动 DeepSpeed 示例。我们建议使用 GitHub 上 DeepSpeed 示例 repo 中的 CIFAR-10 教程。
1#!/bin/bash 2# file: run_cifar10_deepspeed.sh 3 4# Example reference code: 5# https://github.com/microsoft/DeepSpeedExamples/blob/master/training/cifar/cifar10_deepspeed.py 6 7cd /deepspeed_scratch 8 9if [ ! -d DeepSpeedExamples ]; then 10git clone \ 11--single-branch \ 12--depth=1 \ 13# tested using sha dd0f181 14# if necessary, do a deep clone then 15# git reset --hard dd0f181 16--branch=master \ 17https://github.com/microsoft/DeepSpeedExamples.git ; 18fi 19 20export CODEDIR=/deepspeed_scratch/DeepSpeedExamples 21 22# Patch a bug: 23# https://github.com/microsoft/DeepSpeedExamples/issues/222 24sed -i 's%images, labels = dataiter.next()%images, labels = next(dataiter)%g' \ 25${CODEDIR}/training/cifar/cifar10_deepspeed.py && \ 26 27deepspeed \ 28--launcher openmpi \ 29--launcher_args="--allow-run-as-root" \ 30--hostfile="/etc/mpi/hostfile" \ 31--master_addr launcher-svc-${NGC_JOB_ID} \ 32--no_ssh_check \ 33${CODEDIR}/training/cifar/cifar10_deepspeed.py
创建启动脚本后，将其上传到您已创建的 ACE 中的指定工作区。例如
ngc workspace upload --ace <your ace> --org <your org> --team <your team> --source run_cifar10_deepspeed.sh <your workspace>
注意
另一种技术是将脚本作为之前描述的容器镜像构建的一部分包含进来。通过上传到工作区，您可以将启动脚本的生命周期与镜像的生命周期解耦，这在大多数情况下是更可取的。
现在，您已准备好创建一个 BCP 作业来启动 DeepSpeed 训练示例。假设您使用了与启动脚本中规定的相同的挂载点（“deepspeed_scratch”），您可以使用 NGC CLI 工具和以下命令创建一个新作业
1ngc base-command run \ 2--name "run_cifar10_deepspeed" \ 3--org <your org> \ 4--team <your team> \ 5--ace <your ace> \ 6--instance dgxa100.80g.8.norm \ 7--array-type "PYTORCH" \ 8--replicas <node count> \ 9--image "<container with deepspeed installed>" \ 10--result /results \ 11--workspace <your workspace>:/deepspeed_scratch:RW \ 12--total-runtime 15m \ 13--commandline "bash /deepspeed_scratch/run_cifar10_deepspeed.sh"
或者，您也可以使用
bcprun工具运行 DeepSpeed 示例 Python 脚本。bcprun封装了 MPI 和分布式 PyTorch 作业的编排，简化了启动所需的许多参数。对于您的 DeepSpeed 作业，您可以使用此变体替换之前的命令参数1bcprun \ 2--nnodes $NGC_ARRAY_SIZE \ 3--npernode $NGC_GPUS_PER_NODE \ 4--env CODEDIR="/deepspeed_scratch/DeepSpeedExamples/training/cifar" \ 5--cmd "python \${CODEDIR}/cifar10_deepspeed.py"
15. 将 NVIDIA Base Command Platform 与 Weights & Biases 结合使用
15.1. 简介
NVIDIA Base Command™ Platform 是一个面向企业及其数据科学家的优质基础设施解决方案，他们需要世界一流的人工智能 (AI) 开发体验，而无需自己构建。Base Command Platform 提供了一个云托管的 AI 环境，具有完全托管的基础设施。
通过与 Weights & Biases (W&B) 合作，Base Command Platform 用户现在可以访问 W&B 机器学习 (ML) 平台，以快速跟踪实验、对数据集进行版本控制和迭代、评估模型性能、重现模型、可视化结果、发现回归并与同事分享发现。
本指南介绍了如何开始使用 Base Command Platform 和 W&B，并演示了一个快速教程，其中包含在两个平台上进行的示例性深度学习 (DL) 工作流程。
15.2. 设置
15.2.1. Base Command Platform 设置
设置 Base Command Platform 帐户。
请您的团队管理员将您添加到您想要加入的团队或组织。添加后，您将收到一封电子邮件邀请，以加入 NVIDIA Base Command。按照电子邮件邀请中的说明设置您的帐户。有关设置上下文和配置环境的更多信息，请参阅 入职和注册 部分
在登录 Web UI 时，安装并设置 CLI。
按照 https://ngc.nvidia.com/setup/installers/cli 上的说明进行操作。CLI 支持 Linux、Windows 和 MacOS。
生成 API 密钥。
登录 Base Command Platform 后，转到 API 密钥页面，然后选择“生成 API 密钥”。将此密钥存储在安全的地方。API 密钥还将用于配置 CLI 以验证您对 NVIDIA Base Command Platform 的访问。
设置 NGC 上下文。
使用 CLI 登录并输入您的 API 密钥和设置偏好。密钥将被存储以供将来命令使用。
ngc config set系统将提示您输入 API 密钥，然后输入您的上下文，即您的组织/团队（如果使用团队）和 ace。您在 NGC 中的上下文定义了您与团队成员和组织协作的默认范围。
15.2.2. Weights and Biases 设置
访问 Weights & Biases。
您的 Base Command Platform 订阅会自动为您提供对 W&B 高级版的访问权限。创建并设置您的 W&B 帐户的凭据，因为您的 Base Command Platform 帐户未与 W&B 直接集成——也就是说，无法使用您的 Base Command Platform 凭据访问 W&B。
在 Base Command Platform 上创建私有工作区。
使用私有工作区是存储您的配置文件或密钥的便捷选项，以便您可以从所有 Base Command 工作负载中以只读模式访问这些文件或密钥。提示：将工作区命名为 “homews-<帐户名>” 以保持一致性。设置您的 ACE 和组织名称——此处为 “nv_eagledemo-ace” 和 “nv-eagledemo”。
ngc workspace create --name homews-<accountname> --ace nv-eagledemo-ace --org nv-eagledemo
访问您的 W&B API 密钥。
创建帐户后，您可以通过页面顶部的姓名图标 → “设置” → “API 密钥” 访问您的 W&B API 密钥。有关在运行中存储和使用 W&B API 密钥的更多详细信息，请参阅“执行”部分。
15.2.3. 在 Base Command Platform 中存储 W&B 密钥
您在 Base Command Platform 上运行的工作负载必须指定您的 W&B 帐户的凭据和配置，以用于跟踪作业和实验。只需执行一次在 Base Command Platform 工作区中保存 W&B 密钥的操作。可以将主工作区挂载到任何 Base Command Platform 工作负载，以访问之前记录的 W&B 密钥。本节介绍如何生成 W&B API 密钥并将其保存到您的工作区。
用户有两种选项可以将 W&B API 密钥配置到私有主工作区。
15.2.3.1. 选项 1 | 使用 Jupyter Notebook
在 Base Command Platform 上运行交互式 JupyterLab 作业，并将工作区挂载到该作业中。
在我们的示例中，我们使用 homews-demouser 作为工作区。请确保根据您自己的使用情况相应地替换工作区名称和上下文。
CLI
ngc base-command run --name 'wandb_config' --ace nv-eagledemo-ace --instance dgxa100.40g.1.norm \ --result /results --image "nvidia/tensorflow:21.06-tf2-py3" --org nv-eagledemo \ --team nvtest-demo --workspace homews-demouser:/homews-demouser:RW --port 8888 \ --commandline "pip install wandb; jupyter lab --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' --NotebookApp.allow_origin='*' --notebook-dir=/"
请注意，主工作区（此处为 homews-demouser）以读/写模式挂载。
当作业运行时，单击 JupyterLab URL（如作业内的“概述”选项卡上显示）启动会话。
创建新的 Jupyter notebook（例如，“config”），并将以下脚本复制到 notebook 中。
import wandb import os import requests # 1. Login to W&B interactively to specify the API key wandb.login() # 2. Create a directory for configuration files !mkdir -p /homews-demouser/bcpwandb/wandbconf # 3. Copy the file into the configuration folder !cp ~/.netrc /homews-demouser/bcpwandb/wandbconf/config.netrc # 4. Set the login key to the stored W&B API key os.environ["NETRC"]= "/homews-demouser/bcpwandb/wandbconf/config.netrc" # 5. Check current W&B login status and username. Validate the correct API key # The command will output {"email": "xxx@wandb.com", "username": "xxxx"} res = requests.post("https://api.wandb.ai/graphql", json={"query": "query Viewer { viewer { username email } }"}, auth=("api", wandb.api.api_key)) res.json()["data"]["viewer"]
W&B API 密钥现在存储在主工作区 (homews-demouser) 中。
15.2.3.2. 选项 2 | 使用脚本（通过 curl 命令）
在 Base Command Platform 上运行交互式 JupyterLab 作业，并将工作区挂载到该作业中。
在我们的示例中，我们使用 homews-demouser 作为工作区。请确保根据您自己的使用情况相应地替换工作区名称和上下文。
CLI
ngc base-command run --name 'wandb_config' --ace nv-eagledemo-ace --instance dgxa100.40g.1.norm \ --result /results --image "nvidia/tensorflow:21.06-tf2-py3" --org nv-eagledemo \ --team nvtest-demo --workspace homews-demouser:/homews-demouser:RW --port 8888 \ --commandline "pip install wandb; jupyter lab --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' --NotebookApp.allow_origin='*' --notebook-dir=/"
请注意，主工作区（此处为 homews-demouser）以读/写模式挂载。
当作业运行时，单击 JupyterLab URL（如作业内的“概述”选项卡上显示）启动会话。
在 JupyterLab 中启动终端并执行以下命令以创建用户凭据。
请确保根据您自己的使用情况相应地替换工作区名称和上下文。
终端
$ pip install wandb $ curl -sL https://wandb.me/bcp_login | python - config <API key> $ mkdir -p /homews-demouser/bcpwandb/wandbconf $ cp config.netrc /homews-demouser/bcpwandb/wandbconf/config.netrc $ python -c "os.environ["NETRC"]= "/homews-demouser/bcpwandb/wandbconf/config.netrc"
终端输出: ‘API 密钥已写入 config.netrc，通过在 NETRC 环境变量中指定此文件的路径来使用’。
此命令将在您的主工作区中创建一个配置目录，并通过配置文件将 W&B API 密钥存储在此工作区 (homews-demouser) 中。
15.3. 将 W&B 与 JupyterLab 工作负载结合使用
在完成前面的步骤之后，W&B API 密钥已安全地存储在您的私有工作区（此处为 homews-demouser）中的配置文件中。现在，必须将此私有工作区附加到 Base Command Platform 工作负载，才能使用 W&B 帐户和功能。
在下面的部分中，您将创建一个 JupyterLab notebook 作为示例，以显示存储的 API 密钥。使用 TensorFlow 和 Keras 的卷积神经网络进行 MNIST 手写数字分类是一个易于访问的开源模型和数据集，我们将在此工作流程中使用它（可通过 Keras 此处 获取）。
15.3.1. 创建 Jupyter Notebook，包括用于实验跟踪的 W&B 密钥
按照 在 Base Command Platform 中存储 W&B 密钥 下任一选项中的前两个步骤在 Base Command Platform 上创建作业。通过 URL 访问 JupyterLab 后，启动一个新的 Jupyter notebook，其中包含以下代码，并将其另存为私有工作区中的文件 (/homews-demouser/bcpwandb/MNIST_example.ipynb)。
以下示例脚本导入所需的软件包，设置环境，并初始化新的 W&B 运行。随后，它使用 TensorFlow 和 Keras 构建、训练和评估 Convnet 模型，并使用 W&B 跟踪多个指标。
# Imports
!pip install tensorflow
import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
import wandb
import os
# 1. Import the W&B API key from private config workspace by defining NETRC fileos.environ["NETRC"]= "/homews-demouser/bcpwandb/wandbconf/config.netrc"
# 2. Initialize the W&B run
wandb.init(project = "nvtest-repro", id = "MNIST_run_epoch-128_bs-15", name = "NGC-JOB-ID_" + os.environ["NGC_JOB_ID"])
# 3. Prepare the data
# 3.1 Model / data parameters
num_classes = 10
input_shape = (28, 28, 1)
# 3.2 Split data between train and test sets
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
# 3.3 Make sure images have the shape (28, 28, 1)
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
print("x_train shape:", x_train.shape)
print(x_train.shape[0], "train samples")
print(x_test.shape[0], "test samples")
# 3.4 Convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# 4. Build the model
model = keras.Sequential(
[
keras.Input(shape=input_shape),
layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dropout(0.5),
layers.Dense(num_classes, activation="softmax"),
]
)
model.summary()
# 5. Train the model
batch_size = 128
epochs = 15
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=0.1)
# 6. Evaluate the trained model
score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])
# 7. Track metrics with wandb
wandb.log({'loss': score[0], 'accuracy': score[1]})
# 8. Track training configuration with wandb
wandb.config.batch_size = batch_size
wandb.config.epochs = epochs
完成此步骤后，您的主工作区 (homews-demouser) 将包含配置文件和上面创建的示例 Jupyter notebook。
主工作区：/homews-demouser
配置文件：/homews-demouser/bcpwandb/wandbconf/config.netrc
Jupyter notebook：/homews-demouser/bcpwandb/MNIST_example.ipynb
15.3.2. 在批处理模式下运行 W&B 实验
成功完成所有步骤（包括 4.1）后，继续在批处理模式下运行 W&B 实验。请确保根据您自己的使用情况相应地替换工作区名称和上下文。
运行命令
ngc base-command run --name "MNIST_example_batch" --ace nv-eagledemo-ace --instance dgxa100.40g.1.norm \
--commandline "pip install wandb; jupyter lab --allow-root --ip=0.0.0.0 --no-browser --NotebookApp.token='' --NotebookApp.allow_origin='*' --notebook-dir=/ & date; \
cp /homews-demouser/bcpwandb/MNIST_example.ipynb /results && \
touch /results/nb-executing && \
jupyter nbconvert --execute --to=notebook --inplace -y --no-prompt --allow-errors --ExecutePreprocessor.timeout=-1 /results/MNIST_example.ipynb; \
sleep 2h" \
--result /results --image "nvidia/tensorflow:21.06-tf2-py3" --org nv-eagledemo --team nvtest-demo \
--workspace homews-demouser:/homews-demouser:RO --port 8888
pip install wandb确保在启动作业之前安装 wandb 软件包。--commandline参数中的命令 jupyter nbconvert--execute ...将在作业启动后自动执行 Jupyter notebook。
作业完成后，可以在 W&B 仪表板上访问结果，该仪表板提供了给定用户（此处为 nv-testuser）的所有项目的概述。在 W&B 项目中，用户可以比较不同运行之间跟踪的指标（此处为准确率和损失）。
15.4. 在同一项目中运行多个作业的最佳实践
W&B 仅在 wandb.init( ) 命令中运行 ID 发生更改时才识别新的运行。当仅更改运行名称时，W&B 将简单地覆盖已存在的具有相同运行 ID 的运行。或者，要单独记录和跟踪新的运行，用户可以保持相同的运行 ID，但需要在新项目中定义新的运行。
可以在 wandb.init( ) 命令中自定义运行，如下所示
wandb.init(project = "nvtest-demo", id = "MNIST_run_epoch-128_bs-15", name = "NGC-JOB-ID_" + os.environ["NGC_JOB_ID"])
项目：W&B 项目名称应与您的 Base Command Platform 团队名称相对应。在此示例中，Base Command Platform 团队名称 “nvtest-demo” 在 W&B 上反映为项目名称。
Base Command Platform 上的团队名称
W&B 上的项目名称
ID：ID 对于每次运行都是唯一的。它在一个项目中必须是唯一的，如果运行被删除，则 ID 不能重复使用。有关更多详细信息，请参阅 W&B 文档。在此示例中，ID 以 Jupyter notebook 和模型配置命名。
名称：运行名称的目的是在 W&B UI 中标识每次运行。在本示例中，我们根据相关的 NGC 作业 ID 命名每次运行，因此确保每个单独的运行都有不同的名称，以确保轻松区分运行。
15.5. 补充阅读
有关更多信息和详细信息，请参阅本文档的其他章节以及 Weights & Biases 文档。
16. 注销
本章介绍了从系统中注销用户的特性和程序。
只有组织管理员可以注销用户并删除工件（数据集、工作区、结果、容器镜像、模型等）。在从系统中删除用户之前，必须删除或存档用户拥有的所有工件。
执行以下操作
16.1. 删除所有工作区、数据集和结果
要存档，请下载每个项目
ngc workspace download <workspace-id> --dest <path>ngc dataset download <dataset-id> --dest <path>ngc result download <result-id> --dest <path>
要删除项目
ngc workspace remove <workspace-id>ngc dataset remove <dataset-id>ngc result remove <result-id>
16.2. 删除所有容器镜像、图表和资源
要存档，请下载每个项目
ngc registry image pull <repository-name>:<tag>ngc registry chart pull <chart-name>:<version>ngc registry resource download-version <resource-name>:<version>
要删除项目
ngc registry image remove <repository-name>:<tag>ngc registry chart remove <chart-name>:<version>ngc registry resource remove <resource-name>:<version>
16.3. 删除用户
列出当前团队中的用户
ngc team list-users从团队中删除每个用户
ngc team remove-user <user-email>
16.4. 删除团队
删除团队中的所有用户后，删除团队
ngc org remove-team <team-name>
17. 最佳实践
本章包含使用 Base Command Platform 的最佳实践。
17.1. 数据管理最佳实践
17.1.1. 了解数据移动成本
以下是数据可能驻留的不同位置指南
名称 |
定义 |
|---|---|
DGX Cloud |
DGX Cloud 是一项在我们云服务提供商 (CSP) 合作伙伴位置之一运营的服务。数据以 /datasets、/workspaces 和 /results 的形式存储在客户 ACE 上的高速并行文件系统中，可通过 BCP 访问并在作业期间挂载。 |
DGX Cloud 暂存 |
DGX Cloud 暂存是 NVIDIA 提供的对象存储 blob，与为 DGX 订阅客户提供的 ACE 位于同一位置。它旨在允许客户在其订阅开始之前开始通过互联网将其数据上传到 DGX Cloud 数据中心。订阅开始后，客户可以将数据导入到 BCP /datasets 和 /workspaces 中。 它不适用于长期使用，仅在 DGX Cloud 订阅开始时的短期内可用。 |
BCP 本地部署 |
客户场所或托管设施中的 DGX SuperPOD，其上部署了 Base Command Platform，可通过 BCP 界面进行管理。SuperPOD 上的存储位于 SuperPOD 存储合作伙伴的产品之一上。 |
第三方不同云 |
驻留在客户在 CSP 上的帐户中的数据，该 CSP 与用于 DGX Cloud 订阅位置的 CSP 不同。 |
第三方相同云 |
驻留在客户在 CSP 上的帐户中的数据，该 CSP 与用于 DGX Cloud 订阅位置的 CSP 相同。 |
第三方本地部署 |
驻留在客户帐户中的数据，该帐户与他们的 SuperPOD 位于同一位置，但不是 SuperPOD 的主存储。 |
第三方异地部署 |
未与 BCP 本地部署安装在同一位置，并且与 DGX Cloud 或 DGX Cloud 暂存无关的数据。 |
请注意以下数据传输成本注意事项
从 |
到 |
成本 |
|---|---|---|
DGX Cloud |
DGX Cloud 暂存 |
免费 |
DGX Cloud |
BCP 本地部署 |
包含在您的 DGX Cloud 订阅出口限制内 |
DGX Cloud |
第三方不同云 |
包含在您的 DGX Cloud 订阅出口限制内 |
DGX Cloud |
第三方相同云 |
相同云 VPC 间费用 相同云多区域费用 |
DGX Cloud |
客户提供的位置 |
包含在您的 DGX Cloud 订阅出口限制内 |
DGX Cloud 暂存（入职） |
DGX Cloud |
包含 |
DGX Cloud 暂存（入职） |
BCP 本地部署 |
不适用 |
DGX Cloud 暂存（离职） |
客户提供的位置 |
根据请求安排 |
BCP 本地部署 |
DGX Cloud |
客户的互联网服务出口 无 DGX Cloud 入口费用 |
BCP 本地部署 |
DGX Cloud 暂存 |
客户的互联网服务出口费用 |
BCP 本地部署 |
第三方本地部署 |
客户内部 |
BCP 本地部署 |
第三方异地部署 |
客户的互联网服务出口费用 |
第三方本地部署 |
DGX Cloud |
客户的互联网服务出口费用 无 DGX Cloud 入口费用 |
第三方本地部署 |
DGX Cloud 暂存 |
客户的互联网服务出口费用 无 DGX Cloud 入口费用 |
第三方本地部署 |
BCP 本地部署 |
客户内部 |
第三方不同云 |
DGX Cloud |
第三方不同云出口费用 |
第三方不同云 |
DGX Cloud 暂存 |
第三方不同云出口费用 |
第三方相同云 |
DGX Cloud |
相同云 VPC 间费用 相同云多区域费用 |
第三方相同云 |
DGX Cloud 暂存 |
相同云 VPC 间费用 相同云多区域费用 |
第三方异地部署 |
BCP 本地部署 |
第三方异地部署出口费用 |
当将数据传输到 (入口) DGX Cloud 时，DGX Cloud 不收取任何费用。客户可能需要支付客户互联网服务出口费用，具体取决于其数据托管服务提供商，无论是具有明确出口费用的云服务还是具有互联网服务提供商出口到互联网费用的本地部署。
在某些情况下，可以提供与客户 DGX Cloud 实例位于同一区域的预身份验证 URL，以方便暂存，以便批量传输到 DGX Cloud。这用于在 DGX Cloud 订阅之前初始上传数据集。此外，此 DGX Cloud 暂存区域可用于执行 DGX Cloud 数据迁移
（区域 A）-> DGX Cloud 暂存（区域 B）-> DGX Cloud（区域 B）
在 DGX Cloud 暂存对象存储和 DGX Cloud BCP 存储之间传输数据不收取任何费用。但是，DGX Cloud 暂存对象存储旨在短期使用，仅在有限的入职和离职期间为客户提供便利。
客户可以提供自己的对象存储，并将其直接用于 AI 训练作业，而不是使用 BCP 数据集。如果需要，客户还可以使用自己的对象存储来备份训练结果。
17.1.2. 决定是否将数据导入 BCP
作业可以使用 BCP 内部或外部的数据集。例如，作业可以运行一个容器，该容器可以直接访问用户在 AWS 中的 S3 存储桶。
将数据保留在 BCP 外部
在基于实验的工作期间，将现有数据保留在其当前位置可能具有成本效益。作业在 BCP 内部运行，但访问其他位置的对象存储数据。
将数据引入 BCP
客户可以选择将其数据集引入 BCP 以提高作业性能。支持 BCP 的环境（例如，DGX Cloud、DGX SuperPOD）具有性能优化的文件系统来保存其数据集。这种性能优化支持集群范围内的并行读取，以用于大规模训练作业。
在生产工作期间，或者在需要更正式的跟踪时，将数据集引入 BCP 具有以下几个优点：作业跟踪、作业可重现性以及平台内基于角色的数据集共享。
场景 |
建议的数据位置 |
注释 |
|---|---|---|
只有部分数据集使用者正在使用 BCP |
原始的外部存储位置 |
将数据保留在原始位置可以使其保持在中心位置，从而避免了对同步机制的需求。 |
频繁的数据更新 |
原始的外部存储位置 |
将数据保留在原始位置可确保团队中的每个人都在使用最新且一致的数据，从而避免潜在的版本控制问题。 |
大量数据 |
原始的外部存储位置 |
对于非常大的数据集（例如，PB 级），将数据从当前存储中传输出来可能不切实际或不可行。但是，由于在 BCP 作业期间读取 BCP 数据集不收取任何费用（即，没有“GET”费用），因此将数据集传输到 BCP 并重复免费访问它可能更具成本效益。 |
低延迟要求 |
BCP 内部 |
在作业期间将数据与计算硬件放在同一位置，可以为数据访问提供尽可能低的延迟。 |
作业可重现性、验证或可审计性 |
BCP 内部 |
将作业的数据放在 BCP 中意味着完整的数据集信息被记录下来，并且作业是 100% 可重现和可报告的。 |
共享的“官方”数据集 |
BCP 内部 |
如果组织有官方的、不变的数据集（甚至可能是生产级数据集），他们希望在许多用户之间共享这些数据集，则将它们移动到 BCP 中是高效的。 |
17.1.3. BCP 外部的成本效益型数据管理
同一云提供商内的区域到区域传输通常比多区域传输或多云传输成本更低。如果您需要将数据保留在 BCP 外部，则将数据放在与您的 ACE 相同的区域中可能会降低您的成本。
17.1.4. BCP 内部的成本效益型数据管理
如果您的工作流程允许批量处理数据，则可以减少出口请求的数量。您可以在 BCP 仪表板中监控可用存储空间。
17.1.5. 从 BCP 进行成本效益型数据检索
如果您希望在作业完成后将 /results 的内容移出 BCP，则可以将结果数据捆绑和压缩（例如 tar+gzip）以减少要传输的数据总量。与传输大量较小的单个文件相比，该方法减少了大小和事务数量。此方法可以降低远程对象存储的访问成本 (PUTS)，以及出口时间和成本。
17.1.6. 编辑现有数据集时要谨慎
数据集名称在 ACE 中必须是唯一的。因此，如果您尝试添加名称已存在于您的 ACE 中的数据集，您可以选择将第二个数据集“附加”到第一个数据集，或者取消导入/上传。
附加数据集会永久更改现有数据集资源。但是，重复和验证实验通常需要参考最初使用的确切数据集。因此，附加到现有数据集将使先前作业任务中的下游任务失效。
如果您选择附加到 BCP 中的现有数据集，
任何名称不在 BCP 数据集中的文件都将被添加。
任何名称已在 BCP 数据集中的文件都将覆盖原始文件。
17.1.7. 利用“no-team”进行资源共享
要与您的整个组织共享数据集和工作区，请改用团队参数 “no team”。缺少特定的团队标识符将在组织级别共享该资源。
与 “no-team” 共享的数据集将可供该组织中的所有用户查看、在作业期间挂载和导出。
与 “no-team” 共享的工作区将可供该组织中的所有用户查看、在作业期间挂载、扩充和导出。
如果您对组织的围绕向组织共享数据集和工作区的最佳实践有疑问，请与您的 BCP 组织管理员合作。
17.1.8. 监控每用户数据配额
监控用户存储使用情况可确保用户不会突然达到其存储配额并在数据集移动方面受到限制。用户可以选择“请求存储”按钮（如果您的组织已启用）以请求增加存储空间。
用户可以使用 Web UI 中的 BCP 仪表板查看存储配额
用户还可以使用 CLI 查看其存储配额
$ ngc user storage
参考资料
NGC CLI 文档
借助 NVIDIA GPU Cloud (NGC) CLI，您可以执行许多与 NGC Web 应用程序提供的操作相同的操作，例如在您的组织和团队空间内运行作业、查看 Docker 存储库和下载 AI 模型。
NGC API 文档
NGC Web API 是一个用于从 NGC 环境查询信息和在 NGC 环境中进行更改的接口。
声明
声明
本文档仅供参考，不应被视为对产品的特定功能、条件或质量的保证。NVIDIA Corporation（“NVIDIA”）不对本文档中包含的信息的准确性或完整性做出任何明示或暗示的陈述或保证，并且对本文档中包含的任何错误不承担任何责任。NVIDIA 对使用此类信息或因使用此类信息而可能导致的侵犯第三方专利或其他权利的后果不承担任何责任。本文档不构成开发、发布或交付任何材料（下文定义）、代码或功能的承诺。
NVIDIA 保留随时对本文档进行更正、修改、增强、改进和任何其他更改的权利，恕不另行通知。
客户在下订单前应获取最新的相关信息，并应验证此类信息是否为最新且完整。
除非 NVIDIA 和客户的授权代表签署的单独销售协议（“销售条款”）另有约定，否则 NVIDIA 产品受订单确认时提供的 NVIDIA 标准销售条款和条件的约束进行销售。NVIDIA 在此明确反对将任何客户通用条款和条件应用于购买本文档中引用的 NVIDIA 产品。本文档未直接或间接地形成任何合同义务。
NVIDIA 产品并非设计、授权或保证适用于医疗、军事、航空、航天或生命支持设备，也不适用于 NVIDIA 产品的故障或失灵可能合理预期会导致人身伤害、死亡或财产或环境损害的应用。NVIDIA 对在上述设备或应用中包含和/或使用 NVIDIA 产品不承担任何责任，因此，此类包含和/或使用由客户自行承担风险。
NVIDIA 不保证或声明基于本文档的产品将适用于任何特定用途。NVIDIA 不一定对每种产品的所有参数进行测试。客户有责任评估并确定本文档中包含的任何信息的适用性，确保产品适合客户计划的应用，并为该应用执行必要的测试，以避免应用或产品的默认设置。客户产品设计中的缺陷可能会影响 NVIDIA 产品的质量和可靠性，并可能导致超出本文档中包含的附加或不同的条件和/或要求。NVIDIA 对可能基于或归因于以下原因的任何默认设置、损坏、成本或问题不承担任何责任：(i) 以任何违反本文档的方式使用 NVIDIA 产品或 (ii) 客户产品设计。
本文档未授予 NVIDIA 专利权、版权或其他 NVIDIA 知识产权下的任何明示或暗示的许可。NVIDIA 发布的有关第三方产品或服务的信息不构成 NVIDIA 授予使用此类产品或服务的许可，也不构成对产品或服务的保证或认可。使用此类信息可能需要获得第三方的专利或其他知识产权下的许可，或者获得 NVIDIA 的专利或其他 NVIDIA 知识产权下的许可。
只有在事先获得 NVIDIA 书面批准、未经更改地复制且完全符合所有适用的出口法律和法规，并附带所有相关的条件、限制和声明的情况下，才允许复制本文档中的信息。
本文档和所有 NVIDIA 设计规范、参考板、文件、图纸、诊断程序、列表和其他文档（统称为“材料”）均按“原样”提供。NVIDIA 不对材料做出任何明示、暗示、法定或其他方面的保证，并明确否认所有关于非侵权性、适销性和特定用途适用性的默示保证。在法律未禁止的范围内，在任何情况下，NVIDIA 均不对因使用本文档而引起的任何损害（包括但不限于任何直接、间接、特殊、附带、惩罚性或后果性损害，无论因何种原因引起，也无论责任理论如何）承担责任，即使 NVIDIA 已被告知发生此类损害的可能性。尽管客户可能因任何原因而遭受任何损害，但 NVIDIA 对本文所述产品的累计总责任应根据产品的销售条款进行限制。
商标
NVIDIA、NVIDIA 徽标和 Base Command 是 NVIDIA Corporation 在美国和其他国家/地区的商标和/或注册商标。其他公司和产品名称可能是与其相关的各自公司的商标。
版权
© 2023-2024 NVIDIA Corporation 及关联公司。保留所有权利。