华为云用户手册

查询操作 判断一个OBS文件是否存在，如果存在则返回True，如果不存在则返回False。 1 2 import moxing as mox mox.file.exists('obs://bucket_name/sub_dir_0/file.txt') 判断一个OBS文件夹是否存在，如果存在则返回True，如果不存在则返回False。 1 2 import moxing as mox mox.file.exists('obs://bucket_name/sub_dir_0/sub_dir_1') 由于OBS允许同名的文件和文件夹（Unix操作系统不允许），如果存在同名的文件和文件夹，例如“obs://bucket_name/sub_dir_0/abc”，当调用mox.file.exists时，不论abc是文件还是文件夹，都会返回True。 判断一个OBS路径是否为文件夹，如果是则返回True，否则返回False。 1 2 import moxing as mox mox.file.is_directory('obs://bucket_name/sub_dir_0/sub_dir_1') 由于OBS允许同名的文件和文件夹（Unix操作系统不允许），如果存在同名的文件和文件夹，例如obs://bucket_name/sub_dir_0/abc，当调用mox.file.is_directory时，会返回True。 获取一个OBS文件的大小，单位为bytes。 例如获取“obs://bucket_name/obs_file.txt”的文件大小。 1 2 import moxing as mox mox.file.get_size('obs://bucket_name/obs_file.txt') 递归获取一个OBS文件夹下所有文件的大小，单位为bytes。 例如获取“obs://bucket_name/object_dir”目录下所有文件大小的总和。 1 2 import moxing as mox mox.file.get_size('obs://bucket_name/object_dir', recursive=True) 获取一个OBS文件或文件夹的stat信息，stat信息中包含如下信息。 length：文件大小。 mtime_nsec：创建时间戳。 is_directory：是否为目录。 例如查询一个OBS文件“obs://bucket_name/obs_file.txt”，此文件地址也可以替换成一个文件夹地址。 1 2 3 4 5 import moxing as mox stat = mox.file.stat('obs://bucket_name/obs_file.txt') print(stat.length) print(stat.mtime_nsec) print(stat.is_directory)

读写操作 读取一个OBS文件。 例如读取“obs://bucket_name/obs_file.txt”文件内容，返回string（字符串类型）。 1 2 import moxing as mox file_str = mox.file.read('obs://bucket_name/obs_file.txt') 也可以使用打开文件对象并读取的方式来实现，两者是等价的。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.txt', 'r') as f: file_str = f.read() 从文件中读取一行，返回string，以换行符结尾。同样可以打开OBS的文件对象。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.txt', 'r') as f: file_line = f.readline() 从文件中读取所有行，返回一个list，每个元素是一行，以换行符结尾。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.txt', 'r') as f: file_line_list = f.readlines() 以二进制模式读取一个OBS文件。 例如读取“obs://bucket_name/obs_file.bin”文件内容，返回bytes（字节类型）。 1 2 import moxing as mox file_bytes = mox.file.read('obs://bucket_name/obs_file.bin', binary=True) 也可以使用打开文件对象并读取的方式来实现，两者是等价的。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.bin', 'rb') as f: file_bytes = f.read() 以二进制模式打开的文件也支持读取一行或者读取所有行，用法不变。 将字符串写入一个文件。 例如将字符串“Hello World!”写入OBS文件“obs://bucket_name/obs_file.txt”中。 1 2 import moxing as mox mox.file.write('obs://bucket_name/obs_file.txt', 'Hello World!') 也可以使用打开文件对象并写入的方式来实现，两者是等价的。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.txt', 'w') as f: f.write('Hello World!') 用写入模式打开文件或者调用mox.file.write时，如果被写入文件不存在，则会创建，如果已经存在，则会覆盖。 追加一个OBS文件。 例如将字符串“Hello World!”追加到“obs://bucket_name/obs_file.txt”文件中。 1 2 import moxing as mox mox.file.append('obs://bucket_name/obs_file.txt', 'Hello World!') 也可以使用打开文件对象并追加的方式来实现，两者是等价的。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/obs_file.txt', 'a') as f: f.write('Hello World!') 用追加模式打开文件或者调用mox.file.append时，如果被写入文件不存在，则会创建，如果已经存在，则直接追加。 当被追加的源文件比较大时，例如“obs://bucket_name/obs_file.txt”文件大小超过5MB时，追加一个OBS文件的性能比较低。 如果以写入模式或追加模式打开文件，当调用write方法时，待写入内容只是暂时的被存在的缓冲区，直到关闭文件对象（退出with语句时会自动关闭文件对象）或者主动调用文件对象的close()方法或flush()方法时，文件内容才会被写入。

API对应关系 Python：指本地使用Python对本地文件的操作接口。支持一键切换为对应的MoXing文件操作接口（mox.file）。 mox.file：指MoXing框架中用于文件操作的接口，其与python接口一一对应关系。 tf.gfile：指MoXing文件操作接口一一对应的TensorFlow相同功能的接口，在MoXing中，无法自动将文件操作接口自动切换为TensorFlow的接口，下表呈现内容仅表示功能类似，帮助您更快速地了解MoXing文件操作接口的功能。 表1 API对应关系 Python（本地文件操作接口） mox.file（MoXing文件操作接口） tf.gfile（TensorFlow文件操作接口） glob.glob mox.file.glob tf.gfile.Glob os.listdir mox.file.list_directory(..., recursive=False) tf.gfile.ListDirectory os.makedirs mox.file.make_dirs tf.gfile.MakeDirs os.mkdir mox.file.mk_dir tf.gfile.MkDir os.path.exists mox.file.exists tf.gfile.Exists os.path.getsize mox.file.get_size - os.path.isdir mox.file.is_directory tf.gfile.IsDirectory os.remove mox.file.remove(..., recursive=False) tf.gfile.Remove os.rename mox.file.rename tf.gfile.Rename os.scandir mox.file.scan_dir - os.stat mox.file.stat tf.gfile.Stat os.walk mox.file.walk tf.gfile.Walk open mox.file.File tf.gfile.FastGFile(tf.gfile.Gfile) shutil.copyfile mox.file.copy tf.gfile.Copy shutil.copytree mox.file.copy_parallel - shutil.rmtree mox.file.remove(..., recursive=True) tf.gfile.DeleteRecursively

调用mox.file 输入如下代码，实现如下几个简单的功能。 引入MoXing Framework。 在已有的“modelarts-test08/moxing”目录下，创建一个“test01”文件夹。 调用代码检查“test01”文件夹是否存在，如果存在，表示上一个操作已成功。 1 2 3 4 import moxing as mox mox.file.make_dirs('obs://modelarts-test08/moxing/test01') mox.file.exists('obs://modelarts-test08/moxing/test01') 执行结果如图3所示。注意，每输入一行代码，单击下“Run”运行。您也可以进入OBS管理控制台，检查“modelarts-test08/moxing”目录，查看“test01”文件夹是否已创建成功。更多MoXing的常用操作请参见MoXing常用操作的样例代码。 图3 运行示例

引入MoXing Framework的相关说明 在引入MoXing模块后，Python的标准logging模块会被设置为INFO级别，并打印版本号信息。可以通过以下API重新设置logging的等级。 1 2 3 4 import logging from moxing.framework.util import runtime runtime.reset_logger(level=logging.WARNING) 可以在引入MoXing之前，配置环境变量MOX_SILENT_MODE=1，来防止MoXing打印版本号。使用如下Python代码来配置环境变量，需要在import moxing之前就将环境变量配置好。 1 2 3 import os os.environ['MOX_SILENT_MODE'] = '1' import moxing as mox

为什么要用mox.file 使用Python打开一个本地文件，如下所示： 1 2 with open('/tmp/a.txt', 'r') as f: print(f.read()) OBS目录以“obs://”开头，比如“obs://bucket/XXX.txt”。用户无法直接使用open方法打开OBS文件，上面描述的打开本地文件的代码将会报错。 OBS提供了很多方式和工具给用户使用，如SDK、API、console、OBS Browser等，ModelArts mox.file提供了一套更为方便地访问OBS的API，允许用户通过一系列模仿操作本地文件系统的API来操作OBS文件。例如，可以使用以下代码来打开一个OBS上的文件。 1 2 3 import moxing as mox with mox.file.File('obs://bucket_name/a.txt', 'r') as f: print(f.read()) 例如，列举一个本地路径会使用如下Python代码。 1 2 import os os.listdir('/tmp/my_dir/') 如果要列举一个OBS路径，mox.file则需要如下代码： 1 2 import moxing as mox mox.file.list_directory('obs://bucket_name/my_dir/')

创建OBS操作步骤 登录OBS管理控制台，在桶列表页面右上角单击“创建桶”，创建OBS桶。 图2 创建桶 创建桶的区域需要与ModelArts所在的区域一致。例如：当前ModelArts在华北-北京四区域，在 对象存储服务 创建桶时，请选择华北-北京四。 如何查看OBS桶与ModelArts的所处区域，请参见查看OBS桶与ModelArts是否在同一区域。 请勿开启桶加密，ModelArts不支持加密的OBS桶，会导致ModelArts读取OBS中的数据失败。 在桶列表页面，单击桶名称，进入该桶的概览页面。 图3 桶列表 单击左侧导航的“对象”，在对象页面单击新建文件夹，创建OBS文件夹。例如，在已创建的OBS桶“c-flowers”中新建一个文件夹“flowers”。 图4 新建文件夹 在OBS桶中创建完文件夹，即可以上传文件，上传文件操作请参见OBS上传操作。

创建训练作业 本案例创建训练作业时，需要配置如下参数。 表1 创建训练作业的配置说明 参数名称 说明 “创建方式” 选择“自定义算法”。 “启动方式” 选择“自定义”。 “镜像” 选择用于训练的自定义镜像。 “代码目录” 执行本次训练作业所需的代码目录。本文示例的代码目录为“obs://test-modelarts/ascend/code/”。 “启动命令” 镜像的Python启动命令。本文示例的启动命令为“bash ${MA_JOB_DIR}/code/run_torch_ddp_npu.sh”。其中，启动脚本的完整代码请参见代码示例。

代码示例 文件目录结构如下所示，将以下文件上传至OBS桶中： code # 代码根目录 └─torch_ddp.py # PyTorch DDP训练代码文件 └─main.py # 使用PyTorch预置框架功能，通过mp.spawn命令启动训练的启动文件 └─torchlaunch.sh # 使用自定义镜像功能，通过torch.distributed.launch命令启动训练的启动文件 └─torchrun.sh # 使用自定义镜像功能，通过torch.distributed.run命令启动训练的启动文件 torch_ddp.py内容如下： import os import torch import torch.distributed as dist import torch.nn as nn import torch.optim as optim from torch.nn.parallel import DistributedDataParallel as DDP # 用于通过 mp.spawn 启动 def init_from_arg(local_rank, base_rank, world_size, init_method): rank = base_rank + local_rank dist.init_process_group("nccl", rank=rank, init_method=init_method, world_size=world_size) ddp_train(local_rank) # 用于通过 torch.distributed.launch 或 torch.distributed.run 启动 def init_from_env(): dist.init_process_group(backend='nccl', init_method='env://') local_rank=int(os.environ["LOCAL_RANK"]) ddp_train(local_rank) def cleanup(): dist.destroy_process_group() class ToyModel(nn.Module): def __init__(self): super(ToyModel, self).__init__() self.net1 = nn.Linear(10, 10) self.relu = nn.ReLU() self.net2 = nn.Linear(10, 5) def forward(self, x): return self.net2(self.relu(self.net1(x))) def ddp_train(device_id): # create model and move it to GPU with id rank model = ToyModel().to(device_id) ddp_model = DDP(model, device_ids=[device_id]) loss_fn = nn.MSELoss() optimizer = optim.SGD(ddp_model.parameters(), lr=0.001) optimizer.zero_grad() outputs = ddp_model(torch.randn(20, 10)) labels = torch.randn(20, 5).to(device_id) loss_fn(outputs, labels).backward() optimizer.step() cleanup() if __name__ == "__main__": init_from_env() main.py内容如下： import argparse import torch import torch.multiprocessing as mp parser = argparse.ArgumentParser(description='ddp demo args') parser.add_argument('--world_size', type=int, required=True) parser.add_argument('--rank', type=int, required=True) parser.add_argument('--init_method', type=str, required=True) args, unknown = parser.parse_known_args() if __name__ == "__main__": n_gpus = torch.cuda.device_count() world_size = n_gpus * args.world_size base_rank = n_gpus * args.rank # 调用 DDP 示例代码中的启动函数 from torch_ddp import init_from_arg mp.spawn(init_from_arg, args=(base_rank, world_size, args.init_method), nprocs=n_gpus, join=True) torchlaunch.sh内容如下： #!/bin/bash # 系统默认环境变量，不建议修改 MASTER_HOST="$VC_WORKER_HOSTS" MASTER_ADDR="${VC_WORKER_HOSTS%%,*}" MASTER_PORT="6060" JOB_ID="1234" NNODES="$MA_NUM_HOSTS" NODE_RANK="$VC_TASK_INDEX" NGPUS_PER_NODE="$MA_NUM_GPUS" # 自定义环境变量，指定python脚本和参数 PYTHON_SCRIPT=${MA_JOB_DIR}/code/torch_ddp.py PYTHON_ARGS="" CMD="python -m torch.distributed.launch \ --nnodes=$NNODES \ --node_rank=$NODE_RANK \ --nproc_per_node=$NGPUS_PER_NODE \ --master_addr $MASTER_ADDR \ --master_port=$MASTER_PORT \ --use_env \ $PYTHON_SCRIPT \ $PYTHON_ARGS " echo $CMD $CMD torchrun.sh内容如下： PyTorch 2.1版本需要将“rdzv_backend”参数设置为“static：--rdzv_backend=static”。 #!/bin/bash # 系统默认环境变量，不建议修改 MASTER_HOST="$VC_WORKER_HOSTS" MASTER_ADDR="${VC_WORKER_HOSTS%%,*}" MASTER_PORT="6060" JOB_ID="1234" NNODES="$MA_NUM_HOSTS" NODE_RANK="$VC_TASK_INDEX" NGPUS_PER_NODE="$MA_NUM_GPUS" # 自定义环境变量，指定python脚本和参数 PYTHON_SCRIPT=${MA_JOB_DIR}/code/torch_ddp.py PYTHON_ARGS="" if [[ $NODE_RANK == 0 ]]; then EXT_ARGS="--rdzv_conf=is_host=1" else EXT_ARGS="" fi CMD="python -m torch.distributed.run \ --nnodes=$NNODES \ --node_rank=$NODE_RANK \ $EXT_ARGS \ --nproc_per_node=$NGPUS_PER_NODE \ --rdzv_id=$JOB_ID \ --rdzv_backend=c10d \ --rdzv_endpoint=$MASTER_ADDR:$MASTER_PORT \ $PYTHON_SCRIPT \ $PYTHON_ARGS " echo $CMD $CMD

创建训练作业 方式一：使用PyTorch预置框架功能，通过mp.spawn命令启动训练作业。 创建训练作业的关键参数如表1所示。 表1 创建训练作业（预置框架） 参数名称 说明 创建方式 选择“自定义算法”。 启动方式 选择“预置框架”，引擎选择“PyTorch”，PyTorch版本根据训练要求选择。 代码目录 选择OBS桶中训练code文件夹所在路径，例如“obs://test-modelarts/code/”。 启动文件 选择代码目录中训练作业的Python启动脚本。例如“obs://test-modelarts/code/main.py”。 超参 当资源规格为单机多卡时，需要指定超参world_size和rank。 当资源规格为多机时（即实例数大于 1），无需设置超参world_size和rank，超参会由平台自动注入。 方式二：使用自定义镜像功能，通过torch.distributed.launch命令启动训练作业。 创建训练作业的关键参数如表2所示。 表2 创建训练作业（自定义镜像+torch.distributed.launch命令） 参数名称 说明 创建方式 选择“自定义算法”。 启动方式 选择“自定义”。 镜像 选择用于训练的PyTorch镜像。 代码目录 选择OBS桶中训练code文件夹所在路径，例如“obs://test-modelarts/code/”。 启动命令 输入镜像的Python启动命令，例如： bash ${MA_JOB_DIR}/code/torchlaunch.sh 方式三：使用自定义镜像功能，通过torch.distributed.run命令启动训练作业。 创建训练作业的关键参数如表3所示。 表3 创建训练作业（自定义镜像+torch.distributed.run命令） 参数名称 说明 创建方式 选择“自定义算法”。 启动方式 选择“自定义”。 镜像 选择用于训练的PyTorch镜像。 代码目录 选择OBS桶中训练code文件夹所在路径，例如“obs://test-modelarts/code/”。 启动命令 输入镜像的Python启动命令，例如： bash ${MA_JOB_DIR}/code/torchrun.sh

常见问题 示例代码中如何使用不同的数据集？ 上述代码如果使用cifar10数据集，则将数据集下载并解压后，上传至OBS桶中，文件目录结构如下： DDP |--- main.py |--- input_dir |------ cifar-10-batches-py |-------- data_batch_1 |-------- data_batch_2 |-------- ... 其中“DDP”为创建训练作业时的“代码目录”，“main.py”为上文代码示例（即创建训练作业时的“启动文件”），“cifar-10-batches-py”为解压后的数据集文件夹（放在input_dir文件夹下）。 如果使用自定义的随机数据，则将代码示例中的参数“custom_data”改为“true”，修改后内容如下： parser.add_argument('--custom_data', default='true') 然后直接运行代码示例“main.py”即可，创建训练作业的参数与上图相同。 为什么DDP可以不输入主节点ip？ “parser.add_argument('--init_method', default=None, help='tcp_port')”中的init method参数值会包含主节点的ip和端口，由平台自动入参，不需要用户输入主节点的ip和端口。

分布式训练完整代码示例 以下对resnet18在cifar10数据集上的分类任务，给出了分布式训练改造(DDP)的完整代码示例。 训练启动文件main.py内容如下（如果需要执行单机单卡训练作业，则将分布式改造的代码删除）： import datetime import inspect import os import pickle import random import logging import argparse import numpy as np from sklearn.metrics import accuracy_score import torch from torch import nn, optim import torch.distributed as dist from torch.utils.data import TensorDataset, DataLoader from torch.utils.data.distributed import DistributedSampler file_dir = os.path.dirname(inspect.getframeinfo(inspect.currentframe()).filename) def load_pickle_data(path): with open(path, 'rb') as file: data = pickle.load(file, encoding='bytes') return data def _load_data(file_path): raw_data = load_pickle_data(file_path) labels = raw_data[b'labels'] data = raw_data[b'data'] filenames = raw_data[b'filenames'] data = data.reshape(10000, 3, 32, 32) / 255 return data, labels, filenames def load_cifar_data(root_path): train_root_path = os.path.join(root_path, 'cifar-10-batches-py/data_batch_') train_data_record = [] train_labels = [] train_filenames = [] for i in range(1, 6): train_file_path = train_root_path + str(i) data, labels, filenames = _load_data(train_file_path) train_data_record.append(data) train_labels += labels train_filenames += filenames train_data = np.concatenate(train_data_record, axis=0) train_labels = np.array(train_labels) val_file_path = os.path.join(root_path, 'cifar-10-batches-py/test_batch') val_data, val_labels, val_filenames = _load_data(val_file_path) val_labels = np.array(val_labels) tr_data = torch.from_numpy(train_data).float() tr_labels = torch.from_numpy(train_labels).long() val_data = torch.from_numpy(val_data).float() val_labels = torch.from_numpy(val_labels).long() return tr_data, tr_labels, val_data, val_labels def get_data(root_path, custom_data=False): if custom_data: train_samples, test_samples, img_size = 5000, 1000, 32 tr_label = [1] * int(train_samples / 2) + [0] * int(train_samples / 2) val_label = [1] * int(test_samples / 2) + [0] * int(test_samples / 2) random.seed(2021) random.shuffle(tr_label) random.shuffle(val_label) tr_data, tr_labels = torch.randn((train_samples, 3, img_size, img_size)).float(), torch.tensor(tr_label).long() val_data, val_labels = torch.randn((test_samples, 3, img_size, img_size)).float(), torch.tensor( val_label).long() tr_set = TensorDataset(tr_data, tr_labels) val_set = TensorDataset(val_data, val_labels) return tr_set, val_set elif os.path.exists(os.path.join(root_path, 'cifar-10-batches-py')): tr_data, tr_labels, val_data, val_labels = load_cifar_data(root_path) tr_set = TensorDataset(tr_data, tr_labels) val_set = TensorDataset(val_data, val_labels) return tr_set, val_set else: try: import torchvision from torchvision import transforms tr_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms) val_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms) return tr_set, val_set except Exception as e: raise Exception( f"{e}, you can download and unzip cifar-10 dataset manually, " "the data url is http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz") class Block(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.residual_function = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(out_channels) ) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): out = self.residual_function(x) + self.shortcut(x) return nn.ReLU(inplace=True)(out) class ResNet(nn.Module): def __init__(self, block, num_classes=10): super().__init__() self.conv1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)) self.conv2 = self.make_layer(block, 64, 64, 2, 1) self.conv3 = self.make_layer(block, 64, 128, 2, 2) self.conv4 = self.make_layer(block, 128, 256, 2, 2) self.conv5 = self.make_layer(block, 256, 512, 2, 2) self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.dense_layer = nn.Linear(512, num_classes) def make_layer(self, block, in_channels, out_channels, num_blocks, stride): strides = [stride] + [1] * (num_blocks - 1) layers = [] for stride in strides: layers.append(block(in_channels, out_channels, stride)) in_channels = out_channels return nn.Sequential(*layers) def forward(self, x): out = self.conv1(x) out = self.conv2(out) out = self.conv3(out) out = self.conv4(out) out = self.conv5(out) out = self.avg_pool(out) out = out.view(out.size(0), -1) out = self.dense_layer(out) return out def setup_seed(seed): torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) np.random.seed(seed) random.seed(seed) torch.backends.cudnn.deterministic = True def obs_transfer(src_path, dst_path): import moxing as mox mox.file.copy_parallel(src_path, dst_path) logging.info(f"end copy data from {src_path} to {dst_path}") def main(): seed = datetime.datetime.now().year setup_seed(seed) parser = argparse.ArgumentParser(description='Pytorch distribute training', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--enable_gpu', default='true') parser.add_argument('--lr', default='0.01', help='learning rate') parser.add_argument('--epochs', default='100', help='training iteration') parser.add_argument('--init_method', default=None, help='tcp_port') parser.add_argument('--rank', type=int, default=0, help='index of current task') parser.add_argument('--world_size', type=int, default=1, help='total number of tasks') parser.add_argument('--custom_data', default='false') parser.add_argument('--data_url', type=str, default=os.path.join(file_dir, 'input_dir')) parser.add_argument('--output_dir', type=str, default=os.path.join(file_dir, 'output_dir')) args, unknown = parser.parse_known_args() args.enable_gpu = args.enable_gpu == 'true' args.custom_data = args.custom_data == 'true' args.lr = float(args.lr) args.epochs = int(args.epochs) if args.custom_data: logging.warning('you are training on custom random dataset, ' 'validation accuracy may range from 0.4 to 0.6.') ### 分布式改造，DDP初始化进程，其中init_method, rank和world_size参数均由平台自动入参 ### dist.init_process_group(init_method=args.init_method, backend="nccl", world_size=args.world_size, rank=args.rank) ### 分布式改造，DDP初始化进程，其中init_method, rank和world_size参数均由平台自动入参 ### tr_set, val_set = get_data(args.data_url, custom_data=args.custom_data) batch_per_gpu = 128 gpus_per_node = torch.cuda.device_count() if args.enable_gpu else 1 batch = batch_per_gpu * gpus_per_node tr_loader = DataLoader(tr_set, batch_size=batch, shuffle=False) ### 分布式改造，构建DDP分布式数据sampler，确保不同进程加载到不同的数据 ### tr_sampler = DistributedSampler(tr_set, num_replicas=args.world_size, rank=args.rank) tr_loader = DataLoader(tr_set, batch_size=batch, sampler=tr_sampler, shuffle=False, drop_last=True) ### 分布式改造，构建DDP分布式数据sampler，确保不同进程加载到不同的数据 ### val_loader = DataLoader(val_set, batch_size=batch, shuffle=False) lr = args.lr * gpus_per_node * args.world_size max_epoch = args.epochs model = ResNet(Block).cuda() if args.enable_gpu else ResNet(Block) ### 分布式改造，构建DDP分布式模型 ### model = nn.parallel.DistributedDataParallel(model) ### 分布式改造，构建DDP分布式模型 ### optimizer = optim.Adam(model.parameters(), lr=lr) loss_func = torch.nn.CrossEntropyLoss() os.makedirs(args.output_dir, exist_ok=True) for epoch in range(1, max_epoch + 1): model.train() train_loss = 0 ### 分布式改造，DDP sampler, 基于当前的epoch为其设置随机数，避免加载到重复数据 ### tr_sampler.set_epoch(epoch) ### 分布式改造，DDP sampler, 基于当前的epoch为其设置随机数，避免加载到重复数据 ### for step, (tr_x, tr_y) in enumerate(tr_loader): if args.enable_gpu: tr_x, tr_y = tr_x.cuda(), tr_y.cuda() out = model(tr_x) loss = loss_func(out, tr_y) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() print('train | epoch: %d | loss: %.4f' % (epoch, train_loss / len(tr_loader))) val_loss = 0 pred_record = [] real_record = [] model.eval() with torch.no_grad(): for step, (val_x, val_y) in enumerate(val_loader): if args.enable_gpu: val_x, val_y = val_x.cuda(), val_y.cuda() out = model(val_x) pred_record += list(np.argmax(out.cpu().numpy(), axis=1)) real_record += list(val_y.cpu().numpy()) val_loss += loss_func(out, val_y).item() val_accu = accuracy_score(real_record, pred_record) print('val | epoch: %d | loss: %.4f | accuracy: %.4f' % (epoch, val_loss / len(val_loader), val_accu), '\n') if args.rank == 0: # save ckpt every epoch torch.save(model.state_dict(), os.path.join(args.output_dir, f'epoch_{epoch}.pth')) if __name__ == '__main__': main()

训练流程简述 相比于DP，DDP能够启动多进程进行运算，从而大幅度提升计算资源的利用率。可以基于torch.distributed实现真正的分布式计算，具体的原理此处不再赘述。大致的流程如下： 初始化进程组。 创建分布式并行模型，每个进程都会有相同的模型和参数。 创建数据分发Sampler，使每个进程加载一个mini batch中不同部分的数据。 网络中相邻参数分桶，一般为神经网络模型中需要进行参数更新的每一层网络。 每个进程前向传播并各自计算梯度。 模型某一层的参数得到梯度后会马上进行通讯并进行梯度平均。 各GPU更新模型参数。 具体流程图如下： 图1 多机多卡数据并行训练

代码改造点 引入多进程启动机制：初始化进程 引入几个变量：tcp协议，rank进程序号，worldsize开启的进程数量 分发数据：DataLoader中多了一个Sampler参数，避免不同进程数据重复 模型分发：DistributedDataParallel(model) 模型保存：在序号为0的进程下保存模型 import torch class Net(torch.nn.Module): pass model = Net().cuda() ### DistributedDataParallel Begin ### model = torch.nn.parallel.DistributedDataParallel(Net().cuda()) ### DistributedDataParallel End ###

多节点分布式调测适配及代码示例 在DistributedDataParallel中，不同进程分别从原始数据中加载batch的数据，最终将各个进程的梯度进行平均作为最终梯度，由于样本量更大，因此计算出的梯度更加可靠，可以适当增大学习率。 以下对resnet18在cifar10数据集上的分类任务，给出了单机训练和分布式训练改造(DDP)的代码。直接执行代码为多节点分布式训练且支持CPU分布式和GPU分布式，将代码中的分布式改造点注释掉后即可进行单节点单卡训练。 训练代码中包含三部分入参，分别为训练基础参数、分布式参数和数据相关参数。其中分布式参数由平台自动入参，无需自行定义。数据相关参数中的custom_data表示是否使用自定义数据进行训练，该参数为“true”时使用基于torch自定义的随机数据进行训练和验证。 cifar10数据集 在Notebook中，无法直接使用默认版本的torchvision获取数据集，因此示例代码中提供了三种训练数据加载方式。 cifar-10数据集下载链接，单击“CIFAR-10 python version”。 尝试基于torchvision获取cifar10数据集。 基于数据链接下载数据并解压，放置在指定目录下，训练集和测试集的大小分别为(50000，3，32，32)和(10000，3，32，32)。 考虑到下载cifar10数据集较慢，基于torch生成类似cifar10的随机数据集，训练集和测试集的大小分别为(5000，3，32，32)和(1000，3，32，32)，标签仍为10类，指定custom_data = 'true'后可直接进行训练作业，无需加载数据。 训练代码 以下代码中以“### 分布式改造，... ###”注释的代码即为多节点分布式训练需要适配的代码改造点。 不对示例代码进行任何修改，适配数据路径后即可在ModelArts上完成多节点分布式训练。 注释掉分布式代码改造点，即可完成单节点单卡训练。完整代码见分布式训练完整代码示例。 导入依赖包 import datetime import inspect import os import pickle import random import argparse import numpy as np import torch import torch.distributed as dist from torch import nn, optim from torch.utils.data import TensorDataset, DataLoader from torch.utils.data.distributed import DistributedSampler from sklearn.metrics import accuracy_score 定义加载数据的方法和随机数，由于加载数据部分代码较多，此处省略 def setup_seed(seed): torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) np.random.seed(seed) random.seed(seed) torch.backends.cudnn.deterministic = True def get_data(path): pass 定义网络结构 class Block(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.residual_function = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(out_channels) ) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(out_channels) ) def forward(self, x): out = self.residual_function(x) + self.shortcut(x) return nn.ReLU(inplace=True)(out) class ResNet(nn.Module): def __init__(self, block, num_classes=10): super().__init__() self.conv1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)) self.conv2 = self.make_layer(block, 64, 64, 2, 1) self.conv3 = self.make_layer(block, 64, 128, 2, 2) self.conv4 = self.make_layer(block, 128, 256, 2, 2) self.conv5 = self.make_layer(block, 256, 512, 2, 2) self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.dense_layer = nn.Linear(512, num_classes) def make_layer(self, block, in_channels, out_channels, num_blocks, stride): strides = [stride] + [1] * (num_blocks - 1) layers = [] for stride in strides: layers.append(block(in_channels, out_channels, stride)) in_channels = out_channels return nn.Sequential(*layers) def forward(self, x): out = self.conv1(x) out = self.conv2(out) out = self.conv3(out) out = self.conv4(out) out = self.conv5(out) out = self.avg_pool(out) out = out.view(out.size(0), -1) out = self.dense_layer(out) return out 进行训练和验证 def main(): file_dir = os.path.dirname(inspect.getframeinfo(inspect.currentframe()).filename) seed = datetime.datetime.now().year setup_seed(seed) parser = argparse.ArgumentParser(description='Pytorch distribute training', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--enable_gpu', default='true') parser.add_argument('--lr', default='0.01', help='learning rate') parser.add_argument('--epochs', default='100', help='training iteration') parser.add_argument('--init_method', default=None, help='tcp_port') parser.add_argument('--rank', type=int, default=0, help='index of current task') parser.add_argument('--world_size', type=int, default=1, help='total number of tasks') parser.add_argument('--custom_data', default='false') parser.add_argument('--data_url', type=str, default=os.path.join(file_dir, 'input_dir')) parser.add_argument('--output_dir', type=str, default=os.path.join(file_dir, 'output_dir')) args, unknown = parser.parse_known_args() args.enable_gpu = args.enable_gpu == 'true' args.custom_data = args.custom_data == 'true' args.lr = float(args.lr) args.epochs = int(args.epochs) if args.custom_data: print('[warning] you are training on custom random dataset, ' 'validation accuracy may range from 0.4 to 0.6.') ### 分布式改造，DDP初始化进程，其中init_method, rank和world_size参数均由平台自动入参 ### dist.init_process_group(init_method=args.init_method, backend="nccl", world_size=args.world_size, rank=args.rank) ### 分布式改造，DDP初始化进程，其中init_method, rank和world_size参数均由平台自动入参 ### tr_set, val_set = get_data(args.data_url, custom_data=args.custom_data) batch_per_gpu = 128 gpus_per_node = torch.cuda.device_count() if args.enable_gpu else 1 batch = batch_per_gpu * gpus_per_node tr_loader = DataLoader(tr_set, batch_size=batch, shuffle=False) ### 分布式改造，构建DDP分布式数据sampler，确保不同进程加载到不同的数据 ### tr_sampler = DistributedSampler(tr_set, num_replicas=args.world_size, rank=args.rank) tr_loader = DataLoader(tr_set, batch_size=batch, sampler=tr_sampler, shuffle=False, drop_last=True) ### 分布式改造，构建DDP分布式数据sampler，确保不同进程加载到不同的数据 ### val_loader = DataLoader(val_set, batch_size=batch, shuffle=False) lr = args.lr * gpus_per_node max_epoch = args.epochs model = ResNet(Block).cuda() if args.enable_gpu else ResNet(Block) ### 分布式改造，构建DDP分布式模型 ### model = nn.parallel.DistributedDataParallel(model) ### 分布式改造，构建DDP分布式模型 ### optimizer = optim.Adam(model.parameters(), lr=lr) loss_func = torch.nn.CrossEntropyLoss() os.makedirs(args.output_dir, exist_ok=True) for epoch in range(1, max_epoch + 1): model.train() train_loss = 0 ### 分布式改造，DDP sampler, 基于当前的epoch为其设置随机数，避免加载到重复数据 ### tr_sampler.set_epoch(epoch) ### 分布式改造，DDP sampler, 基于当前的epoch为其设置随机数，避免加载到重复数据 ### for step, (tr_x, tr_y) in enumerate(tr_loader): if args.enable_gpu: tr_x, tr_y = tr_x.cuda(), tr_y.cuda() out = model(tr_x) loss = loss_func(out, tr_y) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() print('train | epoch: %d | loss: %.4f' % (epoch, train_loss / len(tr_loader))) val_loss = 0 pred_record = [] real_record = [] model.eval() with torch.no_grad(): for step, (val_x, val_y) in enumerate(val_loader): if args.enable_gpu: val_x, val_y = val_x.cuda(), val_y.cuda() out = model(val_x) pred_record += list(np.argmax(out.cpu().numpy(), axis=1)) real_record += list(val_y.cpu().numpy()) val_loss += loss_func(out, val_y).item() val_accu = accuracy_score(real_record, pred_record) print('val | epoch: %d | loss: %.4f | accuracy: %.4f' % (epoch, val_loss / len(val_loader), val_accu), '\n') if args.rank == 0: # save ckpt every epoch torch.save(model.state_dict(), os.path.join(args.output_dir, f'epoch_{epoch}.pth')) if __name__ == '__main__': main() 结果对比 分别以单机单卡和两节点16卡两种资源类型完成100epoch的cifar-10数据集训练，训练时长和测试集准确率如下。 表1 训练结果对比 资源类型 单机单卡 两节点16卡 耗时 60分钟 20分钟 准确率 80+ 80+

代码改造点 模型分发：DataParallel(model) 完整代码由于代码变动较少，此处进行简略介绍。 import torch class Net(torch.nn.Module): pass model = Net().cuda() ### DataParallel Begin ### model = torch.nn.DataParallel(Net().cuda()) ### DataParallel End ###

相关章节 创建单机多卡的分布式训练（DataParallel）：介绍单机多卡数据并行分布式训练原理和代码改造点。 创建多机多卡的分布式训练（DistributedDataParallel）：介绍多机多卡数据并行分布式训练原理和代码改造点。 示例：创建DDP分布式训练（PyTorch+GPU）：提供了分布式训练调测具体的代码适配操作过程和代码示例。 示例：创建DDP分布式训练（PyTorch+NPU）：针对Resnet18在cifar10数据集上的分类任务，给出了分布式训练改造(DDP)的完整代码示例，供用户学习参考。 基于开发环境使用SDK调测训练作业：介绍如何在ModelArts的开发环境中，使用SDK调测单机和多机分布式训练作业。

分布式训练 分布式训练是指在多个计算节点（如多台服务器或GPU设备）上并行执行深度学习任务，以加快模型训练速度或处理更大规模的数据。通过将训练任务分配到多个节点上，每个节点负责计算模型的一部分，然后通过通信机制将计算结果同步，最终完成整个模型的训练。这种方式可以显著提高训练效率，尤其适用于复杂模型和大规模数据集的场景。 ModelArts 提供了对分布式训练的支持，能够自动配置和管理多节点间的通信与资源分配，从而实现高效的并行计算。 ModelArts提供了如下能力： 丰富的官方预置镜像，满足用户的需求。 支持基于预置镜像自定义制作专属开发环境，并保存使用。 丰富的教程，帮助用户快速适配分布式训练，使用分布式训练极大减少训练时间。 分布式训练调测的能力，可在PyCharm/VSCode/JupyterLab等开发工具中调试分布式训练。 它支持两种主要模式： 单机多卡数据并行（DataParallel, DP）：在同一台服务器上使用多张GPU卡，通过数据并行的方式加速训练。适用于需要充分利用单台服务器多GPU资源的场景。 多机多卡数据并行（DistributedDataParallel, DDP）：通过多台服务器协同工作，每台服务器使用多张GPU卡，进一步扩展训练规模，适用于需要处理大规模数据或复杂模型的场景。

约束限制 总览页面打开的CodeLab不支持此项功能，但是如果用户在AI Gallery中打开了可用的案例，会自动跳转到CodeLab中，此时是可以使用这项功能的。 如果切换了Notebook的规格，那么只能在Notebook进行单机调测，不能进行分布式调测，也不能提交远程训练作业。 当前仅支持PyTorch和MindSpore AI框架，如果MindSpore要进行多机分布式训练调试，则每台机器上都必须有8张卡。 本文档提供的调测代码中涉及到的OBS路径，请用户替换为自己的实际OBS路径。 本文档提供的调测代码是以PyTorch为例编写的，不同的AI框架之间，整体流程是完全相同的，只需要修改个别的参数即可。

约束限制 服务升级关系着业务实现，不当的升级操作会导致升级期间业务中断的情况，请谨慎操作。 ModelArts支持部分场景下在线服务进行无损滚动升级。按要求进行升级前准备，做好验证，即可实现业务不中断的无损升级。 表1 支持无损滚动升级的场景 创建模型的元模型来源 服务使用的是公共资源池 服务使用的是专属资源池 从训练中选择元模型 不支持 不支持 从容器镜像中选择元模型 不支持 支持，创建模型的自定义镜像需要满足创建模型的自定义镜像规范。 从OBS中选择元模型 不支持 不支持

方式二：通过服务详情页面修改服务信息 登录ModelArts管理控制台，在左侧菜单栏中选择“模型部署”，进入目标服务类型管理页面。 单击目标服务名称，进入服务详情页面。 您可以通过单击页面右上角“修改”，修改服务基本信息，然后根据提示提交修改任务。 当修改了服务的某些参数配置时，系统会自动重启服务使修改生效。在提交修改服务任务时，如果涉及重启，会有弹窗提醒。批量服务参数说明请参见将模型部署为批量推理服务。

https示例 使用Flask启动https，Webserver代码示例如下： from flask import Flask, request import json app = Flask(__name__) @app.route('/greet', methods=['POST']) def say_hello_func(): print("----------- in hello func ----------") data = json.loads(request.get_data(as_text=True)) print(data) username = data['name'] rsp_msg = 'Hello, {}!'.format(username) return json.dumps({"response":rsp_msg}, indent=4) @app.route('/goodbye', methods=['GET']) def say_goodbye_func(): print("----------- in goodbye func ----------") return '\nGoodbye!\n' @app.route('/', methods=['POST']) def default_func(): print("----------- in default func ----------") data = json.loads(request.get_data(as_text=True)) return '\n called default func !\n {} \n'.format(str(data)) @app.route('/health', methods=['GET']) def healthy(): return "{\"status\": \"OK\"}" # host must be "0.0.0.0", port must be 8080 if __name__ == '__main__': app.run(host="0.0.0.0", port=8080, ssl_context='adhoc')

在本地机器调试 自定义引擎的规范可以在安装有docker的本地机器上通过以下步骤提前验证： 将自定义引擎镜像下载至本地机器，假设镜像名为custom_engine:v1。 将模型包文件夹复制到本地机器，假设模型包文件夹名字为model。 在模型包文件夹的同级目录下验证如下命令拉起服务： docker run --user 1000:100 -p 8080:8080 -v model:/home/mind/model custom_engine:v1 该指令无法完全模拟线上，主要是由于-v挂载进去的目录是root权限。在线上，模型文件从OBS下载到/home/mind/model目录之后，文件owner将统一修改为ma-user。 在本地机器上启动另一个终端，执行以下验证指令，得到符合预期的推理结果。 curl https://127.0.0.1:8080/${推理服务的请求路径}

背景说明 Server-Sent Events（SSE）是一种服务器向客户端推送数据的技术，它是一种基于HTTP的推送技术，服务器可以向客户端推送事件。这种技术通常用于实现服务器向客户端单向推送实时数据，例如实时新闻更新、股票价格等。 SSE主要解决了客户端与服务器之间的单向实时通信需求（例如ChatGPT回答的流式输出），相较于WebSocket（双向实时），它更加轻量级且易于实现。 使用SSE协议访问在线服务有以下特点： 简单易用：SSE协议基于HTTP协议，实现简单，客户端无需复杂的配置或额外的库支持，可以通过普通的HTTP连接实现数据的实时推送。 自动重连：SSE支持自动重连机制，当连接中断时，客户端会自动尝试重新连接，确保数据推送的连续性。 单向通信：SSE是单向的，服务器可以向客户端发送事件，但客户端不能通过同一个连接向服务器发送数据。 资源占用低：SSE使用HTTP连接，相对于WebSocket等其他实时通信协议，资源占用较低，适合轻量级的实时数据推送场景。

SSE在线服务调用 SSE协议本身不提供额外的认证方式，和HTTP请求方式一致。 可以使用ModelArts提供的以下认证方式： token认证 AK/SK APP认证 SSE服务调用如下（以图形界面的软件Postman进行预测，token认证为例）： 图1 SSE服务调用 图2 响应头Content-Type 正常情况下，可以观察到响应头Content-Type为text/event-stream;charset=UTF-8。

背景说明 WebSocket是一种网络传输协议，可在单个TCP连接上进行全双工通信，位于OSI模型的应用层。WebSocket协议在2011年由IETF标准化为RFC 6455，后由RFC 7936补充规范。Web IDL中的WebSocket API由W3C标准化。 WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就可以建立持久性的连接，并进行双向数据传输。适用于实时通信、在线游戏等需要双向实时通信的场景。 WebSocket适用于需要在ModelArts平台上部署在线服务的场景，特别是当需要使用自定义镜像导入AI模型时。需要注意的是，WebSocket仅支持在线服务，并且在ModelArts平台上使用时，协议会被转换为WSS，支持单向认证。 使用WebSocket协议访问在线服务有以下特点： 持久连接：WebSocket在客户端和服务器之间建立持久连接，无需像HTTP那样频繁建立和断开连接，减少了连接建立的开销。 双向数据传输：支持双向通信，允许服务器主动向客户端推送数据，而不仅仅是响应客户端请求。 减少延迟和带宽消耗：由于连接保持打开状态，数据可以实时传输，减少了延迟，并且减少了不必要的HTTP请求，节省了带宽。

背景说明 访问在线服务的实际业务中，用户可能会存在如下需求： 高吞吐量、低时延 TCP或者RPC请求 因此，ModelArts提供了VPC直连的高速访问通道功能以满足用户的需求。 使用VPC直连的高速访问通道，用户的业务请求不需要经过推理平台，而是直接经VPC对等连接发送到实例处理，访问速度更快。 由于请求不经过推理平台，所以会丢失以下功能： 认证鉴权 流量按配置分发 负载均衡 告警、监控和统计 图1 VPC直连的高速访问通道示意图

实时推理的部署及使用流程 在创建完模型后，可以将模型部署为一个在线服务。当在线服务的状态处于“运行中”，则表示在线服务已部署成功，部署成功的在线服务，将为用户提供一个可调用的API，此API为标准Restful API。访问在线服务时，您可以根据您的业务需求，分别确认使用何种认证方式、访问通道、传输协议，以上三个要素共同构成您的访问请求，三者可自由组合互不影响（例如不同的认证方式可以搭配不同的访问通道、不同的传输协议）。 图1 认证方式、访问通道、传输协议 当前ModelArts支持访问在线服务的认证方式有以下方式（案例中均以HTTPS请求为例）： Token认证：Token具有时效性，有效期为24小时，需要使用同一个Token鉴权时，可以缓存起来，避免频繁调用。 AK/SK认证：使用AK/SK对请求进行签名，在请求时将签名信息添加到消息头，从而通过身份认证。AK/SK签名认证方式仅支持消息体大小12M以内，12M以上的请求请使用Token认证。 APP认证：在请求头部消息增加一个参数即可完成认证，认证方式简单，永久有效。 ModelArts支持通过以下几种方式调用API访问在线服务（案例中均以HTTPS请求为例）： 通过公网访问通道的方式访问在线服务：ModelArts推理默认使用公网访问在线服务。在线服务部署成功后，将为用户提供一个可调用的API，此API为标准Restful API。 通过VPC高速访问通道的方式访问在线服务：使用VPC直连的高速访问通道，用户的业务请求不需要经过推理平台，而是直接经VPC对等连接发送到实例处理，访问速度更快。 在线服务的API默认为HTTPS访问，同时还支持以下的传输协议： 使用WebSocket协议的方式访问在线服务：WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就可以建立持久性的连接，并进行双向数据传输。 使用Server-Sent Events协议的方式访问在线服务：Server-Sent Events访问主要解决了客户端与服务器之间的单向实时通信需求（例如ChatGPT回答的流式输出），相较于WebSocket（双向实时），它更加轻量级且易于实现。 父主题： 将模型部署为实时推理作业

方式二：通过服务详情页面修改服务信息 登录ModelArts管理控制台，在左侧菜单栏中选择“模型部署”，进入目标服务类型管理页面。 单击目标服务名称，进入服务详情页面。 您可以通过单击页面右上角“修改”，修改服务基本信息，然后根据提示提交修改任务。 当修改了服务的某些参数配置时，系统会自动重启服务使修改生效。在提交修改服务任务时，如果涉及重启，会有弹窗提醒。 在线服务参数说明请参见部署模型为在线服务。修改在线服务还需要配置“最大无效实例数”设置并行升级的最大节点数，升级阶段节点无效。 修改在线服务参数时，可通过增加一个自定义的环境变量参数，触发服务重启。例如，如果服务原来部署在公共资源池，则修改环境变量后，服务可能会调度到新的公共资源池。

方式一：通过服务管理页面修改服务信息 登录ModelArts管理控制台，在左侧菜单栏中选择“模型部署”，进入目标服务类型管理页面。 在服务列表中，单击目标服务操作列的“修改”，修改服务基本信息，然后根据提示提交修改任务。 当修改了服务的某些参数配置时，系统会自动重启服务使修改生效。在提交修改服务任务时，如果涉及重启，会有弹窗提醒。 在线服务参数说明请参见部署模型为在线服务。修改在线服务还需要配置“最大无效实例数”设置并行升级的最大节点数，升级阶段节点无效。 修改在线服务参数时，可通过增加一个自定义的环境变量参数，触发服务重启。例如，如果服务原来部署在公共资源池，则修改环境变量后，服务可能会调度到新的公共资源池。