Skip to content

GitLab

"vscode:/vscode.git/clone" did not exist on "e238d34a9042b0b05aa87033e602dd98af2536f8"
Unverified Commit 91d9a797 authored by Yuge Zhang's avatar Yuge Zhang Committed by GitHub
Browse files

Adopt symbolic links in Chinese documentation (#4345) 


Co-authored-by: default avatarjiahangxu <jiahangxu@microsoft.com>
parent 0e0ee86d
Hide whitespace changes
Inline Side-by-side
Showing with 20 additions and 3092 deletions
docs/zh_CN/TrainingService/AdaptDLMode.rst deleted 100644 → 0
View file @ 0e0ee86d
在 AdaptDL 上运行 Experiment
============================
NNI 支持在 `AdaptDL <https://github.com/petuum/adaptdl>`__ 上运行，称为 AdaptDL 模式。 采用 **Kubernetes 1.14** 或更高版本。 根据下面的指南设置 Kubernetes 环境： `on Azure <https://azure.microsoft.com/zh-cn/services/kubernetes-service/>`__\ ， `on-premise <https://kubernetes.io/docs/setup/>`__ ， `cephfs <https://kubernetes.io/docs/concepts/storage/storage-classes/#ceph-rbd>`__\ 和 `microk8s with storage add-on enabled <https://microk8s.io/docs/addons>`__。 在 AdaptDL 模式下，每个 Trial 程序会在 AdaptDL 集群中作为一个 Kubeflow 作业来运行。
AdaptDL 旨在使动态资源环境（例如共享集群和云）中的分布式深度学习变得轻松高效。
部署 Kubernetes 的准备工作
-----------------------------------
#. 采用 **Kubernetes 1.14** 或更高版本。 根据下面的指南设置 Kubernetes 环境： `on Azure <https://azure.microsoft.com/zh-cn/services/kubernetes-service/>`__\ ， `on-premise <https://kubernetes.io/docs/setup/>`__ ， `cephfs <https://kubernetes.io/docs/concepts/storage/storage-classes/#ceph-rbd>`__\ 和 `microk8s with storage add-on enabled <https://microk8s.io/docs/addons>`__。
#. Helm 将 **AdaptDL Scheduler** 安装到 Kubernetes 集群中。 参照 `指南 <https://adaptdl.readthedocs.io/en/latest/installation/install-adaptdl.html>`__ 来设置 AdaptDL scheduler。
#. 配置 **kubeconfig** 文件，NNI 将使用此配置与 Kubernetes API 服务交互。 默认情况下，NNI 管理器会使用 ``$(HOME)/.kube/config`` 作为 kubeconfig 文件的路径。 也可以通过环境变量 **KUBECONFIG** 来指定其它 kubeconfig 文件。 根据 `指南 <https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig>`__ 了解更多 kubeconfig 的信息。
#. 如果 NNI Trial 作业需要 GPU 资源，需按照 `指南 <https://github.com/NVIDIA/k8s-device-plugin>`__ 来配置 **Kubernetes 下的 Nvidia 插件**。
#. （可选）准备 **NFS服务器** 并导出通用装载作为外部存储。
#. 参考 `指南 <../Tutorial/QuickStart.rst>`__ 安装 **NNI**。
验证先决条件
^^^^^^^^^^^^^^^^^^^^
.. code-block:: bash
nnictl --version
# Expected: <version_number>
.. code-block:: bash
kubectl version
# Expected that the kubectl client version matches the server version.
.. code-block:: bash
kubectl api-versions | grep adaptdl
# Expected: adaptdl.petuum.com/v1
运行实验
-----------------
在 ``examples/trials/cifar10_pytorch`` 目录下，``CIFAR10`` 示例充分 handel 了 AdaptDL 调度程序。 (\ ``main_adl.py`` 和 ``config_adl.yaml``\ )
这是将 AdaptDL 用作训练平台的模板配置规范。
.. code-block:: yaml
authorName: default
experimentName: minimal_adl
trainingServicePlatform: adl
nniManagerIp: 10.1.10.11
logCollection: http
tuner:
builtinTunerName: GridSearch
searchSpacePath: search_space.json
trialConcurrency: 2
maxTrialNum: 2
trial:
adaptive: false # optional.
image: <image_tag>
imagePullSecrets: # optional
- name: stagingsecret
codeDir: .
command: python main.py
gpuNum: 1
cpuNum: 1 # optional
memorySize: 8Gi # optional
nfs: # optional
server: 10.20.41.55
path: /
containerMountPath: /nfs
checkpoint: # optional
storageClass: dfs
storageSize: 1Gi
下文中没有提及的 config 可以参考这篇文档：
`默认配置说明 </Tutorial/ExperimentConfig.rst#configuration-spec>`__。
* **trainingServicePlatform**\ : 选择 ``adl`` 以将 Kubernetes 集群与 AdaptDL 调度程序一起使用。
* **nniManagerIp**\ : *必填* ，为了 ``adl`` 训练平台能从群集中获取正确的信息和 metric 。
具有启动 NNI 实验的 NNI 管理器（NNICTL）的计算机的IP地址。
* **logCollection**\ : *推荐* 设置 ``http``。 它将通过 http 将群集上的 trial log 收集到计算机。
* **tuner**\ : 支持 Tuun tuner 和所有的 NNI built-in tuners （仅限于 NNI PBT tuners 的 checkpoint 功能）。
* **trial**\ : 定义了 ``adl`` trial 的规格。
* **namespace**\: （*可选*\ ） Kubernetes 命名空间启动 trial。 默认值是 ``default``。
* **adaptive**\ : （*可选*\ ） 是否开启 AdaptDL trainer。 设置为 ``true``，这项工作是抢占性和适应性的。
* **image**\ : trial 的 docker image。
* **imagePullSecret**\ : （*可选*\ ） 如果使用私人注册表，
需要提供密码才能成功提取 image。
* **codeDir**\ : 容器的工作目录。 ``.`` 意味着默认的工作目录是 image 定义的。
* **command**\ : 启动 trial 的 bash 命令。
* **gpuNum**\ : trial 需要一系列 GPUs。 必须是非负整数。
* **cpuNum**\ : （*可选*\ ） trial 需要一系列 CPUs。 必须是非负整数。
* **memorySize**\ : （*可选*\ ） trial 需要的内存大小。 需要按照 Kubernetes 来。
`默认设置 <https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory>`__。
* **nfs**\ : （*可选*\ ） 安装外部存储。 使用 NFS 的详情请看下文。
* **checkpoint** （*可选*\ ） 模型检查点的存储设置。
* **storageClass**\ : 有关如何使用 ``storageClass`` 请参考 `Kubernetes storage 文档 <https://kubernetes.io/docs/concepts/storage/storage-classes/>`__ 。
* **storageSize**\ : 此值应足够大以适合模型的检查点，否则可能导致 "disk quota exceeded" 错误。
NFS 存储
^^^^^^^^^^^
可能已经在上述配置规范中注意到，
*可选* 部分可用于配置 NFS 外部存储。 当不需要外部存储时，例如 docker image 足以容纳代码和数据时，它是可选的。
请注意，``adl`` 训练平台不能把 NFS 挂载到本地开发机器上，因此可以手动将 NFS 挂载到本地，管理文件系统，复制数据或代码等。
然后，使用适当的配置，``adl`` 训练平台可以针对每个 trial 将其安装到 kubernetes：
* **server**\ : NFS 服务地址，如 IP 地址或者 domain。
* **path**\ : NFS 服务导出路径，如 NFS 中可以安装到 trials 的绝对路径。
* **containerMountPath**\ : 在要安装上述 NFS **path** 的容器绝对路径中，
以便于每条 trial 都可以连上 NFS。
在每个 trial 的容器中，可以用这个路径去连接 NFS。
用例：
* 如果训练 trials 依赖于大型数据集，则可能需要先将其下载到NFS上，
并安装它，以便可以在多个试用版之间共享。
* 容器的存储是临时性的，在试用期结束后，将删除 trial 容器。
因此，如果要导出训练的模型，
可以将NFS安装到试用版上，以保留并导出训练的模型。
简而言之，并没有限制 trial 如何读取或写入 NFS 存储，因此可以根据需要灵活使用它。
通过日志流监控
----------------------------------------------
遵循特定 trial 的日志流：
.. code-block:: bash
nnictl log trial --trial_id=<trial_id>
.. code-block:: bash
nnictl log trial <experiment_id> --trial_id=<trial_id>
请注意，在 trial 结束且其窗格已删除后，
无法通过该命令检索日志。
但是，仍然可以访问过去的试用记录
根据以下方法。
通过 TensorBoard 进行监控
---------------------------------------------
在 NNI 的背景下，一个实验有多条 trial。
为了在模型调整过程的各个 trial 之间轻松进行比较，
我们支持 TensorBoard 集成。 这里有一个实验
一个独立的 TensorBoard 日志目录，即 dashboard。
当被监控的实验处于 running 状态时你可以使用 TensorBoard。
换言之，不支持监视已经停止的实验。
在 trial 容器中，可以访问两个环境变量：
* ``ADAPTDL_TENSORBOARD_LOGDIR``\ : 当前实验 TensorBoard 日志目录，
* ``NNI_TRIAL_JOB_ID``\ : 当前 ``trial`` 的 job id。
建议将它们作为 trial 目录加入，
以 Python 举例：
.. code-block:: python
import os
tensorboard_logdir = os.path.join(
os.getenv("ADAPTDL_TENSORBOARD_LOGDIR"),
os.getenv("NNI_TRIAL_JOB_ID")
)
如果实验停止，记录在此处的数据
（由 *以上envs* 定义，用于使用以下命令进行监视）
会丢掉。 要保留记录的数据，可以使用外部存储设备（例如 安装 NFS)
导出并在本地查看 TensorBoard。
通过上述设置，可以通过 TensorBoard 轻松监控实验。
.. code-block:: bash
nnictl tensorboard start
如果有很多实验同时运行的话，可以使用
.. code-block:: bash
nnictl tensorboard start <experiment_id>
将提供访问 tensorboard 的Web URL。
请注意，可以灵活地为 tensorboard 设置本地 ``--port`` 。
docs/zh_CN/TrainingService/AdaptDLMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/AdaptDLMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/DLCMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/DLCMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/DLTSMode.rst deleted 100644 → 0
View file @ 0e0ee86d
**在 DLTS 上运行 Experiment**
=================================
NNI 支持在 `DLTS <https://github.com/microsoft/DLWorkspace.git>`__\ 上运行 Experiment ，称之为 dlts 模式。 在开始使用 NNI dlts 模式之前，应该有访问 DLTS 仪表板的账号。
设置环境
-----------------
步骤 1. 从 DLTS 仪表板中选择集群，关于仪表板地址，需咨询管理员。
.. image:: ../../img/dlts-step1.png
:target: ../../img/dlts-step1.png
:alt: Choose Cluster
步骤 2. 准备 NNI 配置 YAML，如下所示：
.. code-block:: yaml
# Set this field to "dlts"
trainingServicePlatform: dlts
authorName: your_name
experimentName: auto_mnist
trialConcurrency: 2
maxExecDuration: 3h
maxTrialNum: 100
searchSpacePath: search_space.json
useAnnotation: false
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
trial:
command: python3 mnist.py
codeDir: .
gpuNum: 1
image: msranni/nni
# Configuration to access DLTS
dltsConfig:
dashboard: # Ask administrator for the cluster dashboard URL
记得将群集仪表板地址填到最后一行。
步骤 3. 打开群集的工作目录，将 NNI 配置和相关代码放入目录中。
.. image:: ../../img/dlts-step3.png
:target: ../../img/dlts-step3.png
:alt: Copy Config
步骤 4. 将 NNI 管理器任务提交到指定的群集。
.. image:: ../../img/dlts-step4.png
:target: ../../img/dlts-step4.png
:alt: Submit Job
步骤 5. 转到新创建的任务选项卡，单击端口 40000 的链接检查 Trial 的信息。
.. image:: ../../img/dlts-step5.png
:target: ../../img/dlts-step5.png
:alt: View NNI WebUI
docs/zh_CN/TrainingService/DLTSMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/DLTSMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/FrameworkControllerMode.rst deleted 100644 → 0
View file @ 0e0ee86d
在 FrameworkController 上运行 Experiment
========================================
NNI 支持使用 `FrameworkController <https://github.com/Microsoft/frameworkcontroller>`__，来运行 Experiment，称之为 frameworkcontroller 模式。 FrameworkController 构建于 Kubernetes 上，用于编排各种应用。这样，可以不用为某个深度学习框架安装 Kubeflow 的 tf-operator 或 pytorch-operator 等。 而直接用 FrameworkController 作为 NNI Experiment 的训练平台。
私有部署的 Kubernetes 的准备工作
-----------------------------------------------
#. 采用 **Kubernetes 1.8** 或更高版本。 根据 `指南 <https://kubernetes.io/docs/setup/>`__ 来安装 Kubernetes。
#. 配置 **kubeconfig** 文件，NNI 将使用此配置与 Kubernetes API 服务交互。 默认情况下，NNI 管理器会使用 $(HOME)/.kube/config 作为 kubeconfig 文件的路径。 也可以通过环境变量 **KUBECONFIG** 来指定其它 kubeconfig 文件。 根据 `指南 <https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig>`__ 了解更多 kubeconfig 的信息。
#. 如果 NNI Trial 作业需要 GPU 资源，需按照 `指南 <https://github.com/NVIDIA/k8s-device-plugin>`__ 来配置 **Kubernetes 下的 Nvidia 插件**。
#. 准备 **NFS 服务器** 并导出通用的装载 (mount)，推荐将 NFS 服务器路径映射到 **root_squash 选项**，否则可能会在 NNI 复制文件到 NFS 时出现权限问题。 参考 `页面 <https://linux.die.net/man/5/exports>`__，来了解关于 root_squash 选项，或 **Azure File Storage**。
#. 在安装 NNI 并运行 nnictl 的计算机上安装 **NFS 客户端**。 运行此命令安装 NFSv4 客户端：
.. code-block:: bash
apt-get install nfs-common
7. 参考 `指南 <../Tutorial/QuickStart.rst>`__ 安装 **NNI**。
Azure 部署的 Kubernetes 的准备工作
-----------------------------------------
#. NNI 支持基于 Azure Kubernetes Service 的 Kubeflow，参考 `指南 <https://azure.microsoft.com/zh-cn/services/kubernetes-service/>`__ 来设置 Azure Kubernetes Service。
#. 安装 `Azure CLI <https://docs.microsoft.com/zh-cn/cli/azure/install-azure-cli?view=azure-cli-latest>`__ 和 ``kubectl``。 使用 ``az login`` 命令来设置 Azure 账户，并将 kubectl 客户端连接到 AKS，参考此 `指南 <https://docs.microsoft.com/zh-cn/azure/aks/kubernetes-walkthrough#connect-to-the-cluster>`__。
#. 参考此 `指南 <https://docs.microsoft.com/zh-cn/azure/storage/common/storage-quickstart-create-account?tabs=portal>`__ 来创建 Azure 文件存储账户。 NNI 需要 Azure Storage Service 来存取代码和输出文件。
#. NNI 需要访问密钥来连接 Azure 存储服务，NNI 使用 `Azure Key Vault <https://azure.microsoft.com/zh-cn/services/key-vault/>`__ 服务来保护私钥。 设置 Azure Key Vault 服务，并添加密钥到 Key Vault 中来存取 Azure 存储账户。 参考 `指南 <https://docs.microsoft.com/zh-cn/azure/key-vault/quick-create-cli>`__ 来存储访问密钥。
部署 PVC 存储模式的准备工作
-----------------------------------------
为了使用 PVC（persistent volume claims）而不是 NFS 或 Azure 存储，相关存储必须
在你的 Trial 以后要运行的命名空间中手动创建。 这一限制是由于
PVC 很难被回收，因此会迅速扰乱一个集群的
存储管理， PVC 可以通过 kubectl 被创建。 请参考
`Kubernetes 官方文档 <https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims>`__ 获取更多信息。
安装 FrameworkController
-------------------------
参考 `指南 <https://github.com/Microsoft/frameworkcontroller/tree/master/example/run>`__ 来在 Kubernetes 集群中配置 FrameworkController。NNI 通过 statefulset 模式来 支持 FrameworkController。 如果集群需要认证，则需要为 FrameworkController 创建服务账户并授予权限，然后将 FrameworkController 服务账户的名称设置到 NNI Experiment 配置中。 `参考文档 <https://github.com/Microsoft/frameworkcontroller/tree/master/example/run#run-by-kubernetes-statefulset>`__。
设计
------
请参考 `Kubeflow training service <KubeflowMode.rst>`__ 的设计, FrameworkController training service pipeline 与其相似。
示例
-------
FrameworkController 配置文件的格式如下：
.. code-block:: yaml
authorName: default
experimentName: example_mnist
trialConcurrency: 1
maxExecDuration: 10h
maxTrialNum: 100
#choice: local, remote, pai, kubeflow, frameworkcontroller
trainingServicePlatform: frameworkcontroller
searchSpacePath: ~/nni/examples/trials/mnist-tfv1/search_space.json
#choice: true, false
useAnnotation: false
tuner:
#choice: TPE, Random, Anneal, Evolution
builtinTunerName: TPE
classArgs:
#choice: maximize, minimize
optimize_mode: maximize
assessor:
builtinAssessorName: Medianstop
classArgs:
optimize_mode: maximize
trial:
codeDir: ~/nni/examples/trials/mnist-tfv1
taskRoles:
- name: worker
taskNum: 1
command: python3 mnist.py
gpuNum: 1
cpuNum: 1
memoryMB: 8192
image: msranni/nni:latest
frameworkAttemptCompletionPolicy:
minFailedTaskCount: 1
minSucceededTaskCount: 1
frameworkcontrollerConfig:
storage: nfs
nfs:
server: {your_nfs_server}
path: {your_nfs_server_exported_path}
如果使用了 Azure Kubernetes Service，需要在 YAML 文件中如下设置 ``frameworkcontrollerConfig``：
.. code-block:: yaml
frameworkcontrollerConfig:
storage: azureStorage
serviceAccountName: {your_frameworkcontroller_service_account_name}
keyVault:
vaultName: {your_vault_name}
name: {your_secert_name}
azureStorage:
accountName: {your_storage_account_name}
azureShare: {your_azure_share_name}
注意：如果用 FrameworkController 模式运行，需要在 YAML 文件中显式设置 ``trainingServicePlatform: frameworkcontroller``。
FrameworkController 模式的 Trial 配置格式，是 FrameworkController 官方配置的简化版。参考 `frameworkcontroller 的 tensorflow 示例 <https://github.com/microsoft/frameworkcontroller/blob/master/example/framework/scenario/tensorflow/ps/cpu/tensorflowdistributedtrainingwithcpu.yaml>`__ 了解详情。
frameworkcontroller 模式中的 Trial 配置使用以下主键：
* taskRoles: 配置文件中可以设置多个任务角色，每个任务角色都是在 Kubernetes 集群中的基本执行单元。
* name: 任务角色的名字，例如，"worker", "ps", "master"。
* taskNum: 任务角色的实例数量。
* command: 在容器中要执行的用户命令。
* gpuNum: 容器要使用的 GPU 数量。
* cpuNum: 容器中要使用的 CPU 数量。
* memoryMB: 容器的内存限制。
* image: 用来创建 pod，并运行程序的 Docker 映像。
* frameworkAttemptCompletionPolicy: 运行框架的策略，参考 `用户手册 <https://github.com/Microsoft/frameworkcontroller/blob/master/doc/user-manual.md#frameworkattemptcompletionpolicy>`__ 了解更多信息。 这些策略可以用来控制 pod，例如，如果 worker 任务停止了，但 ps 还在运行，要通过完成策略来停止 ps。
NNI还提供了一个定制 FrameworkController 模板的可能性，类似于
前面提到的 TensorFlow 示例。 一个有效的配置大致如下：
.. code-block:: yaml
experimentName: example_mnist_pytorch
trialConcurrency: 1
maxExecDuration: 1h
maxTrialNum: 2
logLevel: trace
trainingServicePlatform: frameworkcontroller
searchSpacePath: search_space.json
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
assessor:
builtinAssessorName: Medianstop
classArgs:
optimize_mode: maximize
trial:
codeDir: .
frameworkcontrollerConfig:
configPath: fc_template.yml
storage: pvc
namespace: twin-pipelines
pvc:
path: /mnt/data
请注意，在这个例子中，已经使用了 PVC 存储，其必须事先在指定的命名空间中手动创建。 点击 mnist-pytorch 示例 (:githublink: `<examples/trials/mnist-pytorch>`__) 获取更加详细的配置 (:githublink: `<examples/trials/mnist-pytorch/config_frameworkcontroller_custom.yml>`__) 和 FrameworkController 模板 (:githublink: `<examples/trials/fc_template.yml>`__)。
如何运行示例
------------------
准备好配置文件后，通过运行 nnictl 来启动 Experiment。 在 FrameworkController 上开始 Experiment 的方法与 Kubeflow 类似，可参考 `指南 <KubeflowMode.rst>`__ 了解更多信息。
版本校验
-------------
从 0.6 开始，NNI 支持版本校验，详情参考 `这里 <PaiMode.rst>`__。
docs/zh_CN/TrainingService/FrameworkControllerMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/FrameworkControllerMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/HowToImplementTrainingService.rst deleted 100644 → 0
View file @ 0e0ee86d
NNI 中如何实现训练平台
========================================
概述
--------
TrainingService 是与平台管理、任务调度相关的模块。 TrainingService 在设计上为了便于实现，将平台相关的公共属性抽象成类。用户只需要继承这个抽象类，并根据平台特点实现子类，便能够实现 TrainingService。
系统架构
-------------------
.. image:: ../../img/NNIDesign.jpg
:target: ../../img/NNIDesign.jpg
:alt:
NNI 的架构如图所示。 NNIManager 是系统的核心管理模块，负责调用 TrainingService 来管理 Trial，并负责不同模块之间的通信。 Dispatcher 是消息处理中心。 TrainingService 是管理任务的模块，它和 NNIManager 通信，并且根据平台的特点有不同的实现。 ，`远程平台 <RemoteMachineMode.rst>`__\ ， `PAI <PaiMode.rst>`__\ ， `kubeflow <KubeflowMode.rst>`__ 和 `FrameworkController <FrameworkControllerMode.rst>`__。
本文中，会介绍 TrainingService 的简要设计。 如果要添加新的 TrainingService，只需要继承 TrainingServcie 类并实现相应的方法，不需要理解NNIManager、Dispatcher 等其它模块的细节。
代码文件夹结构
------------------------
NNI 的文件夹结构如下：
.. code-block:: bash
nni
|- deployment
|- docs
|- examaples
|- src
| |- nni_manager
| | |- common
| | |- config
| | |- core
| | |- coverage
| | |- dist
| | |- rest_server
| | |- training_service
| | | |- common
| | | |- kubernetes
| | | |- local
| | | |- pai
| | | |- remote_machine
| | | |- test
| |- sdk
| |- webui
|- test
|- tools
| |-nni_annotation
| |-nni_cmd
| |-nni_gpu_tool
| |-nni_trial_tool
``nni/src`` 文件夹存储 NNI 的大部分源代码。 这个文件夹中的代码和 NNIManager、TrainingService、SDK、WebUI 等模块有关。 用户可以在 ``nni/src/nni_manager/common/trainingService.ts`` 文件中找到 TrainingService 抽象类的代码，并且把自己实现的子类放到 ``nni/src/nni_manager/training_service`` 文件夹下。 如果用户实现了自己的 TrainingService，还需要同时实现相应的单元测试代码，并把单元测试放到 ``nni/src/nni_manager/training_service/test`` 文件夹下。
TrainingService 函数解释
--------------------------------------
.. code-block:: bash
abstract class TrainingService {
public abstract listTrialJobs(): Promise<TrialJobDetail[]>;
public abstract getTrialJob(trialJobId: string): Promise<TrialJobDetail>;
public abstract addTrialJobMetricListener(listener: (metric: TrialJobMetric) => void): void;
public abstract removeTrialJobMetricListener(listener: (metric: TrialJobMetric) => void): void;
public abstract submitTrialJob(form: JobApplicationForm): Promise<TrialJobDetail>;
public abstract updateTrialJob(trialJobId: string, form: JobApplicationForm): Promise<TrialJobDetail>;
public abstract get isMultiPhaseJobSupported(): boolean;
public abstract cancelTrialJob(trialJobId: string, isEarlyStopped?: boolean): Promise<void>;
public abstract setClusterMetadata(key: string, value: string): Promise<void>;
public abstract getClusterMetadata(key: string): Promise<string>;
public abstract cleanUp(): Promise<void>;
public abstract run(): Promise<void>;
}
TrainingService 父类有一些抽象方法，用户需要继承并实现这些抽象方法。
**setClusterMetadata(key: string, value: string)**
ClusterMetadata 是与平台细节相关的数据，例如，ClusterMetadata 在远程服务器的定义是：
.. code-block:: bash
export class RemoteMachineMeta {
public readonly ip : string;
public readonly port : number;
public readonly username : string;
public readonly passwd?: string;
public readonly sshKeyPath?: string;
public readonly passphrase?: string;
public gpuSummary : GPUSummary | undefined;
/* GPU Reservation info, the key is GPU index, the value is the job id which reserves this GPU*/
public gpuReservation : Map<number, string>;
constructor(ip : string, port : number, username : string, passwd : string,
sshKeyPath : string, passphrase : string) {
this.ip = ip;
this.port = port;
this.username = username;
this.passwd = passwd;
this.sshKeyPath = sshKeyPath;
this.passphrase = passphrase;
this.gpuReservation = new Map<number, string>();
}
}
Metadata 中包括了主机地址，用户名和其它平台相关配置。 用户需要定义自己的 Metadata 格式，并在这个方法中相应实现。 这个方法在 Experiment 启动之前调用。
**getClusterMetadata(key: string)**
此函数将返回相应值的元数据值，如果不需要使用，可留空。
**submitTrialJob(form: JobApplicationForm)**
SubmitTrialJob 是用来提交新 Trial 任务的函数，需要生成一个 TrialJobDetail 类型的任务实例。 TrialJobDetail 定义如下：
.. code-block:: bash
interface TrialJobDetail {
readonly id: string;
readonly status: TrialJobStatus;
readonly submitTime: number;
readonly startTime?: number;
readonly endTime?: number;
readonly tags?: string[];
readonly url?: string;
readonly workingDirectory: string;
readonly form: JobApplicationForm;
readonly sequenceId: number;
isEarlyStopped?: boolean;
}
根据不同的实现，用户可能需要把 Trial 任务放入队列中，并不断地从队里中取出任务进行提交。 或者也可以直接在这个方法中完成作业提交过程。
**cancelTrialJob(trialJobId: string, isEarlyStopped?: boolean)**
如果此函数被调用，应取消平台启动的 Trial。 不同的平台有不同的取消作业的方式，这个方法应该根据不同平台的特点，实现相应的细节。
**updateTrialJob(trialJobId: string, form: JobApplicationForm)**
调用此函数可更新 Trial 的任务状态，Trial 任务状态根据不同的平台来检测，并需要更新为 ``RUNNING``, ``SUCCEED``, ``FAILED`` 等状态。
**getTrialJob(trialJobId: string)**
此函数根据 trialJobId 返回 trialJob 的实例。
**listTrialJobs()**
用户需要将所有 Trial 任务详情存入列表并返回。
**addTrialJobMetricListener(listener: (metric: TrialJobMetric) => void)**
NNI 会启动一个 EventEmitter 来处理任务的指标数据，如果有检测到有新的数据，EventEmitter 就会被触发，来执行相应的事件。 用户需要在这个方法中开始 EventEmitter。
**removeTrialJobMetricListener(listener: (metric: TrialJobMetric) => void)**
关闭 EventEmitter。
**run()**
Run() 函数是 TrainingService 的主循环，用户可以在这个函数中循环执行他们的代码逻辑，这个函数在实验结束前会一直循环执行。
**cleanUp()**
当实验结束后，此方法用来清除实验环境。 用户需要在这个方法中实现与平台相关的清除操作。
TrialKeeper 工具
----------------
NNI 提供了 TrialKeeper 工具，用来帮助维护 Trial 任务。 可以在 ``nni/tools/nni_trial_tool`` 文件夹中找到 TrialKeeper 的源代码。 如果想要运行在云平台上，这是维护任务的好工具。
TrialKeeper 的架构如下：
.. image:: ../../img/trialkeeper.jpg
:target: ../../img/trialkeeper.jpg
:alt:
当用户需要在远程云平台上运行作业，要把作业启动的命令行传入 TrailKeeper 中，并在远程云平台上启动 TrailKeeper 进程。 注意，TrialKeeper 在远程平台中使用 RESTful 服务来和 TrainingService 进行通信，用户需要在本地机器启动一个 RESTful 服务来接受 TrialKeeper 的请求。 关于 RESTful 服务的源代码可以在 ``nni/src/nni_manager/training_service/common/clusterJobRestServer.ts`` 文件夹中找到。
参考
---------
有关调试的进一步信息，可参考 `这里 <../Tutorial/HowToDebug.rst>`__。
如何参与贡献的指南，请参考 `这里 <../Tutorial/Contributing.rst>`__。
docs/zh_CN/TrainingService/HowToImplementTrainingService.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/HowToImplementTrainingService.rst
\ No newline at end of file
docs/zh_CN/TrainingService/HybridMode.rst deleted 100644 → 0
View file @ 0e0ee86d
**以混合模式进行实验**
===========================================
在混合模式下运行 NNI 意味着 NNI 将在多种培训平台上运行试验工作。 例如，NNI 可以同时将试用作业提交到远程计算机和 AML。
设置环境
-----------------
对于混合模式，NNI 目前支持的平台有 `本地平台 <LocalMode.rst>`__\ ，`远程平台 <RemoteMachineMode.rst>`__\ ， `PAI <PaiMode.rst>`__ 和 `AML <./AMLMode.rst>`__\ 。 使用这些模式开始 Experiment 之前，用户应为平台设置相应的环境。 有关环境设置的详细信息，请参见相应的文档。
运行实验
-----------------
以 ``examples/trials/mnist-tfv1`` 为例。 NNI 的 YAML 配置文件如下：
.. code-block:: yaml
experimentName: example_mnist
searchSpacePath: search_space.json
command: python3 mnist.py
codeDir: .
trialConcurrency: 2
gpuNum: 1
maxExecDuration: 1h
maxTrialNum: 10
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
trainingServicePlatforms:
- remote
machineList:
- ip: 10.1.1.1
username: bob
passwd: bob123
- local
要使用混合训练平台，用户应在 `trainingService` 字段中将训练平台设置为列表。
目前，混合训练平台只支持 `local`, `remote`, `pai` 和 `aml` 训练平台。
docs/zh_CN/TrainingService/HybridMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/HybridMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/KubeflowMode.rst deleted 100644 → 0
View file @ 0e0ee86d
在 Kubeflow 上运行 Experiment
=============================
NNI 支持在 `Kubeflow <https://github.com/kubeflow/kubeflow>`__ 上运行，称为 kubeflow 模式。 NNI 支持基于 Azure Kubernetes Service 的 Kubeflow，参考 `指南 <https://azure.microsoft.com/zh-cn/services/kubernetes-service/>`__ 来设置 Azure Kubernetes Service。 如果不熟悉 Kubernetes，可先浏览 `这里 <https://kubernetes.io/docs/tutorials/kubernetes-basics/>`__ 。 在 kubeflow 模式下，每个 Trial 程序会在 Kubernetes 集群中作为一个 Kubeflow 作业来运行。
私有部署的 Kubernetes 的准备工作
-----------------------------------------------
#. 采用 **Kubernetes 1.8** 或更高版本。 根据 `指南 <https://kubernetes.io/docs/setup/>`__ 来安装 Kubernetes。
#. 在 Kubernetes 集群中下载、安装、部署 **Kubeflow**。 根据 `指南 <https://www.kubeflow.org/docs/started/getting-started/>`__ 来安装 Kubeflow。
#. 配置 **kubeconfig** 文件，NNI 将使用此配置与 Kubernetes API 服务交互。 默认情况下，NNI 管理器会使用 ``$(HOME)/.kube/config`` 作为 kubeconfig 文件的路径。 也可以通过环境变量 **KUBECONFIG** 来指定其它 kubeconfig 文件。 根据 `指南 <https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig>`__ 了解更多 kubeconfig 的信息。
#. 如果 NNI Trial 作业需要 GPU 资源，需按照 `指南 <https://github.com/NVIDIA/k8s-device-plugin>`__ 来配置 **Kubernetes 下的 Nvidia 插件**。
#. 准备 **NFS 服务器** 并导出通用的装载 (mount)，推荐将 NFS 服务器路径映射到 **root_squash 选项**，否则可能会在 NNI 复制文件到 NFS 时出现权限问题。 参考 `页面 <https://linux.die.net/man/5/exports>`__，来了解关于 root_squash 选项，或 **Azure File Storage**。
#. 在安装 NNI 并运行 nnictl 的计算机上安装 **NFS 客户端**。 运行此命令安装 NFSv4 客户端：
.. code-block:: bash
apt-get install nfs-common
7. 参考 `指南 <../Tutorial/QuickStart.rst>`__ 安装 **NNI**。
Azure 部署的 Kubernetes 的准备工作
-----------------------------------------
#. 安装 `Azure CLI <https://docs.microsoft.com/zh-cn/cli/azure/install-azure-cli?view=azure-cli-latest>`__ 和 ``kubectl``。 使用 ``az login`` 命令来设置 Azure 账户，并将 kubectl 客户端连接到 AKS，参考此 `指南 <https://docs.microsoft.com/zh-cn/azure/aks/kubernetes-walkthrough#connect-to-the-cluster>`__。
#. NNI 需要访问密钥来连接 Azure 存储服务，NNI 使用 `Azure Key Vault <https://azure.microsoft.com/zh-cn/services/key-vault/>`__ 服务来保护私钥。 设置 Azure Key Vault 服务，并添加密钥到 Key Vault 中来存取 Azure 存储账户。 参考 `指南 <https://docs.microsoft.com/zh-cn/azure/key-vault/quick-create-cli>`__ 来存储访问密钥。 使用 ``az login`` 命令来设置 Azure 账户，并将 kubectl 客户端连接到 AKS，参考此 `指南 <https://docs.microsoft.com/zh-cn/azure/aks/kubernetes-walkthrough#connect-to-the-cluster>`__。
#. 在 Azure Kubernetes Service 上部署 Kubeflow，参考此 `指南 <https://www.kubeflow.org/docs/started/getting-started/>`__。
#. 参考此 `指南 <https://docs.microsoft.com/zh-cn/azure/storage/common/storage-quickstart-create-account?tabs=portal>`__ 来创建 Azure 文件存储账户。 NNI 需要 Azure Storage Service 来存取代码和输出文件。
#. NNI 需要访问密钥来连接 Azure 存储服务，NNI 使用 `Azure Key Vault <https://azure.microsoft.com/zh-cn/services/key-vault/>`__ 服务来保护私钥。 设置 Azure Key Vault 服务，并添加密钥到 Key Vault 中来存取 Azure 存储账户。 参考 `指南 <https://docs.microsoft.com/zh-cn/azure/key-vault/quick-create-cli>`__ 来存储访问密钥。
设计
------
.. image:: ../../img/kubeflow_training_design.png
:target: ../../img/kubeflow_training_design.png
:alt:
Kubeflow 训练平台会实例化一个 Kubernetes 客户端来与 Kubernetes 集群的 API 服务器交互。
对于每个 Trial，会上传本机 codeDir 路径（在 nni_config.yml 中配置）中的所有文件，包括 parameter.cfg 这样的生成的文件到存储卷中。 如果使用了 Azure 存储，需要在 YAML 文件中如下设置 ``kubeflowConfig``： 当文件准备好后，Kubeflow 训练平台会调用 Kubernetes 的 API 来创建 Kubeflow 作业 (\ `tf-operator <https://github.com/kubeflow/tf-operator>`__ 作业或 `pytorch-operator <https://github.com/kubeflow/pytorch-operator>`__ 作业) ，并将存储卷挂载到作业的 pod 中。 Kubeflow 作业的输出文件，例如 stdout, stderr, trial.log 以及模型文件，也会被复制回存储卷。 NNI 会在网页中显示每个 Trial 的存储卷的 URL，以便浏览日志和输出文件。
支持的操作符（operator）
------------------------------------
NNI 仅支持 Kubeflow 的 tf-operator 和 pytorch-operator，其它操作符未经测试。
可以在配置文件中设置操作符类型。
这是 tf-operator 的设置：
.. code-block:: yaml
kubeflowConfig:
operator: tf-operator
这是 pytorch-operator 的设置：
.. code-block:: yaml
kubeflowConfig:
operator: pytorch-operator
如果要使用 tf-operator，需要在 Trial 配置中设置 ``ps`` 和 ``worker``。如果要使用 pytorch-operator，需要在 Trial 配置中设置 ``master`` 和 ``worker``。
支持的存储类型
----------------------
NNI 支持使用 NFS 和 Azure 存储来存储代码和输出文件，可在配置文件进行相应的配置。
NFS 存储配置如下：
.. code-block:: yaml
kubeflowConfig:
storage: nfs
nfs:
# Your NFS server IP, like 10.10.10.10
server: {your_nfs_server_ip}
# Your NFS server export path, like /var/nfs/nni
path: {your_nfs_server_export_path}
如果使用了 Azure 存储，需要在 YAML 文件中如下设置 ``kubeflowConfig``：
.. code-block:: yaml
kubeflowConfig:
storage: azureStorage
keyVault:
vaultName: {your_vault_name}
name: {your_secert_name}
azureStorage:
accountName: {your_storage_account_name}
azureShare: {your_azure_share_name}
运行实验
-----------------
以 ``examples/trials/mnist-tfv1`` 为例。 这是一个 TensorFlow 作业，使用了 Kubeflow 的 tf-operator。 NNI 的 YAML 配置文件如下：
.. code-block:: yaml
authorName: default
experimentName: example_mnist
trialConcurrency: 2
maxExecDuration: 1h
maxTrialNum: 20
#choice: local, remote, pai, kubeflow
trainingServicePlatform: kubeflow
searchSpacePath: search_space.json
#choice: true, false
useAnnotation: false
tuner:
#choice: TPE, Random, Anneal, Evolution
builtinTunerName: TPE
classArgs:
#choice: maximize, minimize
optimize_mode: maximize
assessor:
builtinAssessorName: Medianstop
classArgs:
optimize_mode: maximize
trial:
codeDir: .
worker:
replicas: 2
command: python3 dist_mnist.py
gpuNum: 1
cpuNum: 1
memoryMB: 8196
image: msranni/nni:latest
ps:
replicas: 1
command: python3 dist_mnist.py
gpuNum: 0
cpuNum: 1
memoryMB: 8196
image: msranni/nni:latest
kubeflowConfig:
operator: tf-operator
apiVersion: v1alpha2
storage: nfs
nfs:
# Your NFS server IP, like 10.10.10.10
server: {your_nfs_server_ip}
# Your NFS server export path, like /var/nfs/nni
path: {your_nfs_server_export_path}
注意：如果用 Kubeflow 模式运行，需要在 YAML 文件中显式设置 ``trainingServicePlatform: kubeflow``。
如果要运行 Pytorch 作业，需要如下配置：
.. code-block:: yaml
authorName: default
experimentName: example_mnist_distributed_pytorch
trialConcurrency: 1
maxExecDuration: 1h
maxTrialNum: 10
#choice: local, remote, pai, kubeflow
trainingServicePlatform: kubeflow
searchSpacePath: search_space.json
#choice: true, false
useAnnotation: false
tuner:
#choice: TPE, Random, Anneal, Evolution
builtinTunerName: TPE
classArgs:
#choice: maximize, minimize
optimize_mode: minimize
trial:
codeDir: .
master:
replicas: 1
command: python3 dist_mnist.py
gpuNum: 1
cpuNum: 1
memoryMB: 2048
image: msranni/nni:latest
worker:
replicas: 1
command: python3 dist_mnist.py
gpuNum: 0
cpuNum: 1
memoryMB: 2048
image: msranni/nni:latest
kubeflowConfig:
operator: pytorch-operator
apiVersion: v1alpha2
nfs:
# Your NFS server IP, like 10.10.10.10
server: {your_nfs_server_ip}
# Your NFS server export path, like /var/nfs/nni
path: {your_nfs_server_export_path}
kubeflow 模式的配置有下列主键：
* codeDir
* 代码目录，存放训练代码和配置文件
* worker (必填)。 此部分用于配置 TensorFlow 的 worker 角色
* replicas
* 必填。 需要运行的 TensorFlow woker 角色的数量，必须为正数。
* command
* 必填。 用来运行 Trial 作业的命令，例如：``python mnist.py``。
* memoryMB
* 必填。 Trial 程序的内存需求，必须为正数。
* cpuNum
* gpuNum
* image
* 必填。 在 kubeflow 模式中，Kubernetes 会安排 Trial 程序在 `Pod <https://kubernetes.io/docs/concepts/workloads/pods/pod/>`__ 中执行。 此键用来指定 Trial 程序的 pod 使用的 Docker 映像。
* 我们已经 build 了一个 docker image :githublink:`msranni/nni <deployment/docker/Dockerfile>`。 可以直接使用此映像，或参考它来生成自己的映像。
* privateRegistryAuthPath
* 可选字段，指定 ``config.json`` 文件路径。此文件，包含了 Docker 注册的认证令牌，用来从私有 Docker 中拉取映像。 `参考文档 <https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/>`__。
* apiVersion
* 必填。 Kubeflow 的 API 版本。
.. cannot find :githublink:`msranni/nni <deployment/docker/Dockerfile>`
* ps (可选)。 此部分用于配置 TensorFlow 的 parameter 服务器角色。
* master (可选)。 此部分用于配置 PyTorch 的 parameter 服务器角色。
完成并保存 NNI Experiment 配置文件后（例如可保存为：exp_kubeflow.yml），运行以下命令：
.. code-block:: bash
nnictl create --config exp_kubeflow.yml
来在 Kubeflow 模式下启动实验。 NNI 会为每个 Trial 创建 Kubeflow tfjob 或 pytorchjob，作业名称的格式为 ``nni_exp_{experiment_id}_trial_{trial_id}``。
可以在 Kubernetes 面板中看到创建的 Kubeflow tfjob。
注意：Kubeflow 模式下，NNIManager 会启动 RESTful 服务，监听端口为 NNI 网页服务器的端口加1。 例如，如果网页端口为 ``8080``，那么 RESTful 服务器会监听在 ``8081`` 端口，来接收运行在 Kubernetes 中的 Trial 作业的指标。 因此，需要在防火墙中启用端口 ``8081`` 的 TCP 协议，以允许传入流量。
当一个 Trial 作业完成后，可以在 NNI 网页的概述页面（如：http://localhost:8080/oview）中查看 Trial 的信息。
版本校验
-------------
从 0.6 开始，NNI 支持版本校验，详情参考 `这里 <PaiMode.rst>`__。
如果在使用 Kubeflow 模式时遇到任何问题，请到 `NNI Github repo <https://github.com/Microsoft/nni>`__ 中创建问题。
docs/zh_CN/TrainingService/KubeflowMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/KubeflowMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/LocalMode.rst deleted 100644 → 0
View file @ 0e0ee86d
**教程：使用 NNI API 在本地创建和运行 Experiment**
================================================================================================================================
本教程会使用 [~/examples/trials/mnist-pytorch] 示例来解释如何在本地使用 NNI API 来创建并运行 Experiment。
..
在开始前
要有一个使用卷积层对 MNIST 分类的代码，如 ``mnist_before.py``。
..
第一步：更新模型代码
对代码进行以下改动来启用 NNI API：
1.1 声明 NNI API 在 Trial 代码中通过 ``import nni`` 来导入 NNI API。
1.2 获取预定义参数
使用一下代码段：
.. code-block:: python
tuner_params = nni.get_next_parameter()
获得 tuner 分配的超参数值。 ``tuner_params`` 是一个对象，例如：
.. code-block:: json
{"batch_size": 32, "hidden_size": 128, "lr": 0.01, "momentum": 0.2029}
..
1.3 导出 NNI results API：``nni.report_intermediate_result(accuracy)`` 发送 ``accuracy`` 给 assessor。 使用 API: ``nni.report_final_result(accuracy)`` 返回 ``accuracy`` 的值给 Tuner。
将改动保存到 ``mnist.py`` 文件中。
**注意**：
.. code-block:: bash
accuracy - 如果使用内置的 Tuner/Assessor，那么 `accuracy` 必须是数值（如 float, int）。在定制 Tuner/Assessor 时 `accuracy` 可以是任何类型的 Python 对象。
Assessor（评估器）- 会根据 Trial 的历史值（即其中间结果），来决定这次 Trial 是否应该提前终止。
Tuner（调参器） - 会根据探索的历史（所有 Trial 的最终结果）来生成下一组参数、架构。
..
第二步：定义搜索空间
在 ``Step 1.2 获取预定义的参数`` 中使用的超参定义在 ``search_space.json`` 文件中：
.. code-block:: bash
{
"batch_size": {"_type":"choice", "_value": [16, 32, 64, 128]},
"hidden_size":{"_type":"choice","_value":[128, 256, 512, 1024]},
"lr":{"_type":"choice","_value":[0.0001, 0.001, 0.01, 0.1]},
"momentum":{"_type":"uniform","_value":[0, 1]}
}
参考 `define search space <../Tutorial/SearchSpaceSpec.rst>`__ 进一步了解搜索空间。
..
第三步：定义 Experiment
..
3.1 启用 NNI API 模式
要启用 NNI 的 API 模式，需要将 useAnnotation 设置为 *false*，并提供搜索空间文件的路径（即第一步中定义的文件）：
.. code-block:: bash
useAnnotation: false
searchSpacePath: /path/to/your/search_space.json
在 NNI 中运行 Experiment，只需要：
* 可运行的 Trial 的代码
* 实现或选择 Tuner
* 准备 YAML 的 Experiment 配置文件
* （可选）实现或选择 Assessor
**准备 trial**\ :
..
安装 NNI 之后，NNI 的样例已经在目录 ``nni/examples`` 下，运行 ``ls nni/examples/trials`` 可以看到所有的 examples。
以一个简单的 trial 来举例。 NNI 提供了 mnist 样例。 安装 NNI 之后，NNI 的样例已经在目录 ~/nni/examples下，运行 ``ls ~/nni/examples/trials`` 可以看到所有的 examples。 执行下面的命令可轻松运行 NNI 的 mnist 样例：
.. code-block:: bash
python ~/nni/examples/trials/mnist-annotation/mnist.py
上面的命令会写在 YAML 文件中。 参考 `这里 <../TrialExample/Trials.rst>`__ 来写出自己的 Experiment 代码。
**准备 Tuner**： NNI 支持多种流行的自动机器学习算法，包括：Random Search（随机搜索），Tree of Parzen Estimators (TPE)，Evolution（进化算法）等等。 也可以实现自己的 Tuner（参考 `这里 <../Tuner/CustomizeTuner.rst>`__）。下面使用了 NNI 内置的 Tuner：
.. code-block:: bash
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
*builtinTunerName* 用来指定 NNI 中的 Tuner，*classArgs* 是传入到 Tuner 的参数（内置 Tuner 在 `这里 <../Tuner/BuiltinTuner.rst>`__\ ），*optimization_mode* 表明需要最大化还是最小化 Trial 的结果。
**准备配置文件**\：实现 Trial 的代码，并选择或实现自定义的 Tuner 后，就要准备 YAML 配置文件了。 NNI 为每个 Trial 示例都提供了演示的配置文件，用命令 ``cat ~/nni/examples/trials/mnist-annotation/config.yml`` 来查看其内容。 大致内容如下：
.. code-block:: yaml
authorName: your_name
experimentName: auto_mnist
# 同时运行的 trial 数量
trialConcurrency: 1
# 实验最大运行时长
maxExecDuration: 3h
# 此项设置为 empty 意为无限大
maxTrialNum: 100
# choice: local, remote
trainingServicePlatform: local
# search space file
searchSpacePath: search_space.json
# choice: true, false
useAnnotation: true
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
trial:
command: python mnist.py
codeDir: ~/nni/examples/trials/mnist-annotation
gpuNum: 0
因为这个 Trial 代码使用了 NNI Annotation 的方法（参考 `这里 <../Tutorial/AnnotationSpec.rst>`__ ），所以 *useAnnotation* 为 true。 *command* 是运行 Trial 代码所需要的命令，*codeDir* 是 Trial 代码的相对位置。 命令会在此目录中执行。 同时，也需要提供每个 Trial 进程所需的 GPU 数量。
完成上述步骤后，可通过下列命令来启动 Experiment：
.. code-block:: bash
nnictl create --config ~/nni/examples/trials/mnist-annotation/config.yml
参考 `这里 <../Tutorial/Nnictl.rst>`__ 来了解 *nnictl* 命令行工具的更多用法。
查看 Experiment 结果
-----------------------
Experiment 应该一直在运行。 除了 *nnictl* 以外，还可以通过 NNI 的网页来查看 Experiment 进程，进行控制和其它一些有意思的功能。
使用多个本地 GPU 加快搜索速度
--------------------------------------------
以下步骤假定在本地安装了4个 NVIDIA GPU，并且 `具有 GPU 支持的 tensorflow <https://www.tensorflow.org/install/gpu>`__。 演示启用了 4 个并发的 Trial 任务，每个 Trial 任务使用了 1 块 GPU。
**准备配置文件**：NNI 提供了演示用的配置文件，使用 ``cat examples/trials/mnist-annotation/config_gpu.yml`` 来查看。 trailConcurrency 和 gpuNum 与基本配置文件不同：
.. code-block:: bash
...
# how many trials could be concurrently running
trialConcurrency: 4
...
trial:
command: python mnist.py
codeDir: ~/nni/examples/trials/mnist-annotation
gpuNum: 1
用下列命令运行 Experiment：
.. code-block:: bash
nnictl create --config ~/nni/examples/trials/mnist-annotation/config_gpu.yml
可以用 *nnictl* 命令行工具或网页界面来跟踪训练过程。 *nvidia_smi* 命令行工具能在训练过程中查看 GPU 使用情况。
docs/zh_CN/TrainingService/LocalMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/LocalMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/Overview.rst deleted 100644 → 0
View file @ 0e0ee86d
训练平台
================
什么是训练平台？
-------------------------
NNI 训练平台让用户专注于 AutoML 任务，不需要关心 Trial 实际运行的计算基础架构平台。 当从一个集群迁移到另一个集群时 (如，从本机迁移到 Kubeflow)，用户只需要调整几项配置，能很容易的扩展计算资源。
用户可以使用 NNI 提供的训练平台来跑 trial, 训练平台有：`local machine <./LocalMode.rst>`__\ ， `remote machines <./RemoteMachineMode.rst>`__\ 以及集群类的 `PAI <./PaiMode.rst>`__\ ，`Kubeflow <./KubeflowMode.rst>`__\ ，`AdaptDL <./AdaptDLMode.rst>`__\ ， `FrameworkController <./FrameworkControllerMode.rst>`__\ ， `DLTS <./DLTSMode.rst>`__ 和 `AML <./AMLMode.rst>`__。 这些都是 *内置的训练平台*。
如果需要在计算资源上使用 NNI，可以根据相关接口，轻松构建对其它训练平台的支持。 详情请参考 `如何实施训练平台 <./HowToImplementTrainingService.rst>`__ 。
如何使用训练平台？
----------------------------
在 Experiment 的 YAML 配置文件中选择并配置好训练平台。 参考相应训练平台的文档来了解如何配置。 `此文档 <../Tutorial/ExperimentConfig.rst>`__ 提供了更多详细信息。
然后，需要准备代码目录，将路径填入配置文件的 ``codeDir`` 字段。 注意，非本机模式下，代码目录会在 Experiment 运行前上传到远程或集群中。 因此，NNI 将文件数量限制到 2000，总大小限制为 300 MB。 如果 codeDir 中包含了过多的文件，可添加 ``.nniignore`` 文件来排除部分，与 ``.gitignore`` 文件用法类似。 写好这个文件请参考 :githublink:`示例 <examples/trials/mnist-tfv1/.nniignore>` 和 `git 文档 <https://git-scm.com/docs/gitignore#_pattern_format>`__。
如果用户需要在 Experiment 使用大文件（如，大规模的数据集），并且不想使用本机模式，可以：1) 在 Trial command 字段中添加命令，每次 Trial 运行前下载数据；或 2) 使用工作节点可访问的共享存储。 通常情况下，训练平台都会有共享存储。 参考每个训练平台的文档，了解详情。
内置训练平台
--------------------------
.. list-table::
:header-rows: 1
:widths: auto
* - 训练平台
- 简介
* - `Local <./LocalMode.rst>`__
- NNI 支持在本机运行实验，称为 local 模式。 local 模式表示 NNI 会在运行 NNI Manager 进程计算机上运行 Trial 任务，支持 GPU 调度功能。
* - `Remote <./RemoteMachineMode.rst>`__
- NNI 支持通过 SSH 通道在多台计算机上运行 Experiment，称为 remote 模式。 NNI 需要这些计算机的访问权限，并假定已配置好了深度学习训练环境。 NNI 将在远程计算机上中提交 Trial 任务，并根据 GPU 资源调度 Trial 任务。
* - `PAI <./PaiMode.rst>`__
- NNI 支持在 `OpenPAI <https://github.com/Microsoft/pai>`__ (aka PAI) 上运行 Experiment，即 pai 模式。 在使用 NNI 的 pai 模式前, 需要有 `OpenPAI <https://github.com/Microsoft/pai>`__ 群集的账户。 如果没有 OpenPAI 账户，参考 `这里 <https://github.com/Microsoft/pai#how-to-deploy>`__ 来进行部署。 在 pai 模式中，会在 Docker 创建的容器中运行 Trial 程序。
* - `Kubeflow <./KubeflowMode.rst>`__
- NNI 支持在 `Kubeflow <https://github.com/kubeflow/kubeflow>`__ 上运行，称为 kubeflow 模式。 在开始使用 NNI 的 Kubeflow 模式前，需要有一个 Kubernetes 集群，可以是私有部署的，或者是 `Azure Kubernetes Service(AKS) <https://azure.microsoft.com/zh-cn/services/kubernetes-service/>`__，并需要一台配置好 `kubeconfig <https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/>`__ 的 Ubuntu 计算机连接到此 Kubernetes 集群。 如果不熟悉 Kubernetes，可先浏览 `这里 <https://kubernetes.io/docs/tutorials/kubernetes-basics/>`__ 。 在 kubeflow 模式下，每个 Trial 程序会在 Kubernetes 集群中作为一个 Kubeflow 作业来运行。
* - `AdaptDL <./AdaptDLMode.rst>`__
- NNI 支持在 `AdaptDL <https://github.com/petuum/adaptdl>`__ 上运行，称为 AdaptDL 模式。 在开始使用 AdaptDL 模式之前，应该具有 Kubernetes 集群。
* - `FrameworkController <./FrameworkControllerMode.rst>`__
- NNI 支持使用 `FrameworkController <https://github.com/Microsoft/frameworkcontroller>`__，来运行 Experiment，称之为 frameworkcontroller 模式。 FrameworkController 构建于 Kubernetes 上，用于编排各种应用。这样，可以不用为某个深度学习框架安装 Kubeflow 的 tf-operator 或 pytorch-operator 等。 而直接用 FrameworkController 作为 NNI Experiment 的训练平台。
* - `DLTS <./DLTSMode.rst>`__
- NNI 支持在 `DLTS <https://github.com/microsoft/DLWorkspace.git>`__ 上运行 Experiment，这是一个由微软开源的工具包。
* - `AML <./AMLMode.rst>`__
- NNI 支持在 `AML <https://azure.microsoft.com/zh-cn/services/machine-learning/>`__ 上运行 Experiment，称为 aml 模式。
训练平台做了什么？
------------------------------
.. raw:: html
<p align="center">
<img src="https://user-images.githubusercontent.com/23273522/51816536-ed055580-2301-11e9-8ad8-605a79ee1b9a.png" alt="drawing" width="700"/>
</p>
根据 `概述 <../Overview.rst>`__ 中展示的架构，训练平台会做三件事：1) 启动 Trial; 2) 收集指标，并与 NNI 核心（NNI 管理器）通信；3) 监控 Trial 任务状态。 为了展示训练平台的详细工作原理，下面介绍了训练平台从最开始到第一个 Trial 运行成功的过程。
步骤 1. **验证配置，并准备训练平台。** 训练平台会首先检查用户配置是否正确（例如，身份验证是否有错）。 然后，训练平台会为 Experiment 做准备，创建训练平台可访问的代码目录（ ``codeDir`` ）。
.. Note:: 不同的训练平台会有不同的方法来处理 ``codeDir``。 例如，本机训练平台会直接在 ``codeDir`` 中运行 Trial。 远程训练平台会将 ``codeDir`` 打包成 zip 文件，并上传到每台机器中。 基于 Kubernetes 的训练平台会将 ``codeDir`` 复制到共享存储上，此存储可以由训练平台提供，或者用户在配置文件中指定。
步骤 2. **提交第一个 Trial。** 要初始化 Trial，通常（在不重用环境的情况下），NNI 会复制一些文件（包括参数配置，启动脚本等）到训练平台中。 然后，NNI 会通过子进程、SSH、RESTful API 等方式启动 Trial。
.. Warning:: Trial 当前目录的内容与 ``codeDir`` 会完全一样，但可能是完全不同的路径（甚至不同的计算机）。本机模式是唯一一个所有 Trial 都使用同一个 ``codeDir`` 的训练平台。 其它训练平台，会将步骤 1 中准备好的 ``codeDir``，从共享目录复制到每个 Trial 自己独立的工作目录下。 强烈建议不要依赖于本机模式下的共享行为，这会让 Experiment 很难扩展到其它训练平台上。
步骤 3. **收集 metrics。** NNI 监视记录 trial 状态，更新 trial 的状态（例如，从 ``WAITING`` to ``RUNNING``，从 ``RUNNING`` 到 ``SUCCEEDED``），并收集 metrics 。 当前，大部分训练平台都实现为 "主动" 模式，即，训练平台会调用 NNI 管理器上的 RESTful API 来更新指标。 注意，这也需要运行 NNI 管理器的计算机能被工作节点访问到。
重用模式下的训练平台
---------------------------------
启用重用模式后，一个集群，例如远程机器或 AML 上的计算实例，将启动一个长期运行的环境，以便 NNI 将 Trial 迭代地提交到这些环境，从而节省创建新任务的时间。 例如，在重用模式下使用 OpenPAI 训练平台可以避免重复拉取 docker 镜像、创建容器和下载数据的开销。
在重用模式下，用户需要确保每个 Trial 可以在同一任务中独立运行（例如，避免加载先前 Trial 的检查点）。
.. note:: 目前，只有 `Local <./LocalMode.rst>`__, `Remote <./RemoteMachineMode.rst>`__, `OpenPAI <./PaiMode.rst>`__ 和 `AML <./AMLMode.rst>`__ 训练平台支持重用模式。 对于 Remote 和 OpenPAI 训练平台，您可以根据 `这里 <../reference/experiment_config.rst>`__ 手动启用重用模式。 AML是在重用模式下实现的，所以默认模式是重用模式，不需要手动启用。
docs/zh_CN/TrainingService/Overview.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/Overview.rst
\ No newline at end of file
docs/zh_CN/TrainingService/PaiMode.rst deleted 100644 → 0
View file @ 0e0ee86d
.. role:: raw-html(raw)
:format: html
**在 OpenPAI 上运行 Experiment**
====================================
NNI 支持在 `OpenPAI <https://github.com/Microsoft/pai>`__ 上运行 Experiment，即 pai 模式。 在使用 NNI 的 pai 模式前, 需要有 `OpenPAI <https://github.com/Microsoft/pai>`__ 群集的账户。 如果没有 OpenPAI 账户，参考 `这里 <https://github.com/Microsoft/pai#how-to-deploy>`__ 来进行部署。 在 pai 模式中，会在 Docker 创建的容器中运行 Trial 程序。
.. toctree::
设置环境
-----------------
**步骤 1. 参考 `指南 <../Tutorial/QuickStart.rst>`__ 安装 NNI。**
**步骤 2. 获得令牌（token）。**
打开 OpenPAI 的 Web 界面，并点击右上方的 ``My profile`` 按钮。
.. image:: ../../img/pai_profile.jpg
:scale: 80%
点击页面中的 ``copy`` 按钮来复制 jwt 令牌。
.. image:: ../../img/pai_token.jpg
:scale: 67%
**步骤 3. 将 NFS 存储挂在到本地计算机。**
点击 Web 界面中的 ``Submit job`` 按钮。
.. image:: ../../img/pai_job_submission_page.jpg
:scale: 50%
找到作业提交页面中的数据管理部分。
.. image:: ../../img/pai_data_management_page.jpg
:scale: 33%
``Preview container paths`` 是 API 提供的 NFS 主机和路径，需要将对应的位置挂载到本机，然后 NNI 才能使用 NFS 存储。
例如，使用下面的命令。
.. code-block:: bash
sudo mount -t nfs4 gcr-openpai-infra02:/pai/data /local/mnt
然后将容器中的 ``/ data`` 文件夹安装到本地计算机的 ``/ local / mnt`` 文件夹中。\ :raw-html:`<br>`
可以在NNI的配置文件中使用以下配置：
.. code-block:: yaml
nniManagerNFSMountPath: /local/mnt
**步骤 4. 获得 OpenPAI 存储的配置名称和 nniManagerMountPath**
``Team share storage`` 字段是在 OpenPAI 中指定存储配置的值。 可以在 ``Team share storage`` 中找到 ``paiStorageConfigName`` 和 ``containerNFSMountPath`` 字段，如：
.. code-block:: yaml
paiStorageConfigName: confignfs-data
containerNFSMountPath: /mnt/confignfs-data
运行实验
-----------------
以 ``examples/trials/mnist-annotation`` 为例。 NNI 的 YAML 配置文件如下：
.. code-block:: yaml
authorName: your_name
experimentName: auto_mnist
# how many trials could be concurrently running
trialConcurrency: 2
# maximum experiment running duration
maxExecDuration: 3h
# empty means never stop
maxTrialNum: 100
# choice: local, remote, pai
trainingServicePlatform: pai
# search space file
searchSpacePath: search_space.json
# choice: true, false
useAnnotation: true
tuner:
builtinTunerName: TPE
classArgs:
optimize_mode: maximize
trial:
command: python3 mnist.py
codeDir: ~/nni/examples/trials/mnist-annotation
gpuNum: 0
cpuNum: 1
memoryMB: 8196
image: msranni/nni:latest
virtualCluster: default
nniManagerNFSMountPath: /local/mnt
containerNFSMountPath: /mnt/confignfs-data
paiStorageConfigName: confignfs-data
# Configuration to access OpenPAI Cluster
paiConfig:
userName: your_pai_nni_user
token: your_pai_token
host: 10.1.1.1
# optional, experimental feature.
reuse: true
注意：如果用 pai 模式运行，需要在 YAML 文件中设置 ``trainingServicePlatform: pai`` 。 配置文件中的 host 字段是 OpenPAI 作业提交页面的地址，例如：``10.10.5.1``，NNI 中默认协议是 ``http``，如果 OpenPAI 集群启用了 https，则需要使用 ``https://10.10.5.1`` 的格式。
Trial 配置
^^^^^^^^^^^^^^^^^^^^
与 `LocalMode <LocalMode.rst>`__ 和 `RemoteMachineMode <RemoteMachineMode.rst>`__\ 相比， pai 模式下的 ``trial`` 配置有下面所列的其他 keys：
*
cpuNum
可选。 Trial 程序的 CPU 需求，必须为正数。 如果没在 Trial 配置中设置，则需要在 ``paiConfigPath`` 指定的配置文件中设置。
*
memoryMB
可选。 Trial 程序的内存需求，必须为正数。 如果没在 Trial 配置中设置，则需要在 ``paiConfigPath`` 指定的配置文件中设置。
*
image
可选。 在 pai 模式下，OpenPAI 将安排试用程序在 `Docker 容器 <https://www.docker.com/>`__ 中运行。 此键用来指定 Trial 程序的容器使用的 Docker 映像。
我们已经 build 了一个 docker image :githublink:`nnimsra/nni <deployment/docker/Dockerfile>`。 可以直接使用此映像，或参考它来生成自己的映像。 如果没在 Trial 配置中设置，则需要在 ``paiConfigPath`` 指定的配置文件中设置。
.. cannot find :githublink:`nnimsra/nni <deployment/docker/Dockerfile>`
*
virtualCluster
可选。 设置 OpenPAI 的 virtualCluster，即虚拟集群。 如果未设置此参数，将使用默认的虚拟集群。
*
nniManagerNFSMountPath
必填。 在 nniManager 计算机上设置挂载的路径。
*
containerNFSMountPath
必填。 在 OpenPAI 的容器中设置挂载路径。
*
paiStorageConfigName:
可选。 设置 OpenPAI 中使用的存储名称。 如果没在 Trial 配置中设置，则需要在 ``paiConfigPath`` 指定的配置文件中设置。
*
command
可选。 设置 OpenPAI 容器中使用的命令。
*
paiConfigPath
可选。 设置 OpenPAI 作业配置文件路径，文件为 YAML 格式。
如果用户在配置文件中设置了 ``paiConfigPath``，那么就无需声明以下字段： ``command`` ， ``paiStorageConfigName``\ ， ``virtualCluster``\ ， ``image``\ ， ``memoryMB``\ ， ``cpuNum``\ 和 ``gpuNum`` 。 这些字段将使用 ``paiConfigPath`` 指定的配置文件中的值。
注意：
#.
OpenPAI 配置文件中的作业名称会由 NNI 指定，格式为：``nni_exp_${this.experimentId}_trial_${trialJobId}`` 。
#.
如果在 OpenPAI 配置文件中有多个 taskRoles，NNI 会将这些 taksRoles 作为一个 Trial 任务，用户需要确保只有一个 taskRole 会将指标上传到 NNI 中，否则可能会产生错误。
OpenPAI 配置
^^^^^^^^^^^^^^^^^^^^^^
``paiConfig`` 包括了 OpenPAI 的专门配置，
*
userName
必填。 OpenPAI 平台的用户名。
*
token
必填。 OpenPAI 平台的身份验证密钥。
*
host
必填。 OpenPAI 平台的主机。 OpenPAI 作业提交页面的地址，例如：``10.10.5.1``，NNI 中默认协议是 ``http``，如果 OpenPAI 集群启用了 https，则需要使用 ``https://10.10.5.1`` 的格式。
*
reuse (测试版功能)
可选，默认为 false。 如果为 true，NNI 会重用 OpenPAI 作业，在其中运行尽可能多的 Trial。 这样可以节省创建新作业的时间。 用户需要确保同一作业中的每个 Trial 相互独立，例如，要避免从之前的 Trial 中读取检查点。
完成并保存 NNI Experiment 配置文件后（例如可保存为：exp_pai.yml），运行以下命令：
.. code-block:: bash
nnictl create --config exp_pai.yml
来在 pai 模式下启动 Experiment。 NNI 会为每个 Trial 创建 OpenPAI 作业，作业名称的格式为 ``nni_exp_{experiment_id}_trial_{trial_id}``。
可以在 OpenPAI 集群的网站中看到 NNI 创建的作业，例如：
.. image:: ../../img/nni_pai_joblist.jpg
:target: ../../img/nni_pai_joblist.jpg
:alt:
注意：pai 模式下，NNIManager 会启动 RESTful 服务，监听端口为 NNI 网页服务器的端口加 1。 例如，如果网页端口为 ``8080``，那么 RESTful 服务器会监听在 ``8081`` 端口，来接收运行在 Kubernetes 中的 Trial 作业的指标。 因此，需要在防火墙中启用端口 ``8081`` 的 TCP 协议，以允许传入流量。
当一个 Trial 作业完成后，可以在 NNI 网页的概述页面（如：http://localhost:8080/oview）中查看 Trial 的信息。
在 Trial 列表页面中展开 Trial 信息，点击如下的 logPath：
.. image:: ../../img/nni_webui_joblist.png
:scale: 30%
接着将会打开 HDFS 的 WEB 界面，并浏览到 Trial 的输出文件：
.. image:: ../../img/nni_trial_hdfs_output.jpg
:scale: 80%
在输出目录中可以看到三个文件：stderr，stdout 以及 trial.log。
数据管理
---------------
使用 NNI 启动 Experiment 前，应在 nniManager 计算机中设置相应的挂载数据的路径。 OpenPAI 有自己的存储（NFS、AzureBlob ...），在 OpenPAI 中使用的存储将在启动作业时挂载到容器中。 应通过 ``paiStorageConfigName`` 字段选择 OpenPAI 中的存储类型。 然后，应将存储挂载到 nniManager 计算机上，并在配置文件中设置 ``nniManagerNFSMountPath``，NNI会生成 bash 文件并将 ``codeDir`` 中的数据拷贝到 ``nniManagerNFSMountPath`` 文件夹中，然后启动 Trial 任务。 ``nniManagerNFSMountPath`` 中的数据会同步到 OpenPAI 存储中，并挂载到 OpenPAI 的容器中。 容器中的数据路径在 ``containerNFSMountPath`` 设置，NNI 将进入该文件夹，运行脚本启动 Trial 任务。
版本校验
-------------
从 0.6 开始，NNI 支持版本校验。 确保 NNIManager 与 trialKeeper 的版本一致，避免兼容性错误。
检查策略：
#. 0.6 以前的 NNIManager 可与任何版本的 trialKeeper 一起运行，trialKeeper 支持向后兼容。
#. 从 NNIManager 0.6 开始，与 triakKeeper 的版本必须一致。 例如，如果 NNIManager 是 0.6 版，则 trialKeeper 也必须是 0.6 版。
#. 注意，只有版本的前两位数字才会被检查。例如，NNIManager 0.6.1 可以和 trialKeeper 的 0.6 或 0.6.2 一起使用，但不能与 trialKeeper 的 0.5.1 或 0.7 版本一起使用。
如果 Experiment 无法运行，而且不能确认是否是因为版本不匹配造成的，可以在 Web 界面检查是否有相关的错误消息。
.. image:: ../../img/webui-img/experimentError.png
:scale: 80%
docs/zh_CN/TrainingService/PaiMode.rst 0 → 120000
View file @ 91d9a797
../../en_US/TrainingService/PaiMode.rst
\ No newline at end of file
docs/zh_CN/TrainingService/RemoteMachineMode.rst deleted 100644 → 0
View file @ 0e0ee86d
在远程计算机上运行 Experiment
====================================
NNI 可以通过 SSH 在多个远程计算机上运行同一个 Experiment，称为 ``remote`` 模式。 这就像一个轻量级的训练平台。 在此模式下，可以从计算机启动 NNI，并将 Trial 并行调度到远程计算机。
远程计算机的操作系统支持 ``Linux``\ ， ``Windows 10`` 和 ``Windows Server 2019``。
必需组件
------------
*
确保远程计算机的默认环境符合 Trial 代码的需求。 如果默认环境不符合要求，可以将设置脚本添加到 NNI 配置的 ``command`` 字段。
*
确保远程计算机能被运行 ``nnictl`` 命令的计算机通过 SSH 访问。 同时支持 SSH 的密码和密钥验证方法。 高级用法请参考 `machineList part of configuration <../Tutorial/ExperimentConfig.rst>`__ 。
*
确保每台计算机上的 NNI 版本一致。
*
如果要同时使用远程 Linux 和 Windows，请确保 Trial 的命令与远程操作系统兼容。 例如，Python 3.x 的执行文件在 Linux 下是 ``python3``，在 Windows 下是 ``python``。
Linux
^^^^^
* 按照 `安装教程 <../Tutorial/InstallationLinux.rst>`__ 在远程计算机上安装 NNI 。
Windows
^^^^^^^
*
按照 `安装教程 <../Tutorial/InstallationLinux.rst>`__ 在远程计算机上安装 NNI 。
*
安装并启动 ``OpenSSH Server``。
#.
在 Windows 上打开 ``设置`` 应用。
#.
点击 ``应用``，然后点击 ``可选功能``。
#.
点击 ``添加功能``，找到并选择 ``OpenSSH 服务器``，然后点击 ``安装``。
#.
安装后，运行下列命令来启动服务并设为自动启动。
.. code-block:: bat
sc config sshd start=auto
net start sshd
*
确保远程账户为管理员权限，以便可以停止运行中的 Trial。
*
确保除了默认消息外，没有别的欢迎消息，否则会导致 NodeJS 中的 ssh2 出错。 例如，如果在 Azure 中使用了 Data Science VM，需要删除 ``C:\dsvm\tools\setup\welcome.bat`` 中的 echo 命令。
打开新命令窗口，如果输入如下，则表示正常。
.. code-block:: text
Microsoft Windows [Version 10.0.17763.1192]
(c) 2018 Microsoft Corporation. All rights reserved.
(py37_default) C:\Users\AzureUser>
运行实验
-----------------
例如， 有三台机器，可使用用户名和密码登录。
.. list-table::
:header-rows: 1
:widths: auto
* - IP
- Username
- Password
* - 10.1.1.1
- bob
- bob123
* - 10.1.1.2
- bob
- bob123
* - 10.1.1.3
- bob
- bob123
在这三台计算机或另一台能访问这些计算机的环境中安装并运行 NNI。
以 ``examples/trials/mnist-annotation`` 为例。 示例文件 ``examples/trials/mnist-annotation/config_remote.yml`` 的内容如下：
.. code-block:: yaml
authorName: default
experimentName: example_mnist
trialConcurrency: 1
maxExecDuration: 1h
maxTrialNum: 10
#choice: local, remote, pai
trainingServicePlatform: remote
# search space file
searchSpacePath: search_space.json
#choice: true, false
useAnnotation: true
tuner:
#choice: TPE, Random, Anneal, Evolution, BatchTuner
#SMAC (SMAC should be installed through nnictl)
builtinTunerName: TPE
classArgs:
#choice: maximize, minimize
optimize_mode: maximize
trial:
command: python3 mnist.py
codeDir: .
gpuNum: 0
# machineList can be empty if the platform is local
machineList:
- ip: 10.1.1.1
username: bob
passwd: bob123
# port can be skip if using default ssh port 22
# port: 22
- ip: 10.1.1.2
username: bob
passwd: bob123
- ip: 10.1.1.3
username: bob
passwd: bob123
``codeDir`` 中的文件会自动上传到远程计算机中。 可在 Windows、Linux 或 macOS 上运行以下命令，在远程 Linux 计算机上启动 Trial：
.. code-block:: bash
nnictl create --config examples/trials/mnist-annotation/config_remote.yml
配置 Python 环境
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
默认情况下，命令和脚本将在远程计算机的默认环境中执行。 如果远程机器上有多个 python 虚拟环境，并且想在特定环境中运行实验，请使用 **pythonPath** 来指定远程计算机上的 Python 环境。
以 ``examples/trials/mnist-tfv2`` 为例。 示例文件 ``examples/trials/mnist-tfv2/config_remote.yml`` 的内容如下：
.. code-block:: yaml
authorName: default
experimentName: example_mnist
trialConcurrency: 1
maxExecDuration: 1h
maxTrialNum: 10
#choice: local, remote, pai
trainingServicePlatform: remote
searchSpacePath: search_space.json
#choice: true, false
useAnnotation: false
tuner:
#choice: TPE, Random, Anneal, Evolution, BatchTuner, MetisTuner
#SMAC (SMAC should be installed through nnictl)
builtinTunerName: TPE
classArgs:
#choice: maximize, minimize
optimize_mode: maximize
trial:
command: python3 mnist.py
codeDir: .
gpuNum: 0
#machineList can be empty if the platform is local
machineList:
- ip: ${replace_to_your_remote_machine_ip}
username: ${replace_to_your_remote_machine_username}
sshKeyPath: ${replace_to_your_remote_machine_sshKeyPath}
# Below is an example of specifying python environment.
pythonPath: ${replace_to_python_environment_path_in_your_remote_machine}
远程计算机支持以重用模式运行实验。 在这种模式下，NNI 将重用远程机器任务来运行尽可能多的 Trial。这样可以节省创建新作业的时间。用户需要确保同一作业中的每个 Trial 相互独立，例如，要避免从之前的 Trial 中读取检查点。
按照以下设置启用重用模式：
.. code-block:: yaml
remoteConfig:
reuse: true
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment