1 概述本文将介绍如何将PyTorch源码转换成MindSpore低阶API代码,并在Ascend芯片上实现单机单卡训练。下图展示了MindSpore高阶API、低阶API和PyTorch的训练流程的区别。 与MindSpore高阶API相同，低阶API训练也需要进行：配置运行信息、数据读取和预处理、网络定义、定义损失函数和优化器。具体步骤同高阶API。2 构造模型(低阶API)构造模型时，首先将网络原型与损失函数封装，再将组合的模型与优化器封装，最终组合成一个可用于训练的网络。 由于训练并验证中，需计算在训练集上的精度 ，因此返回值中需包含网络的输出值。import mindsporefrom mindspore import Modelimport mindspore.nn as nnfrom mindspore.ops import functional as Ffrom mindspore.ops import operations as Pclass BuildTrainNetwork(nn.Cell):    '''Build train network.'''    def __init__(self, my_network, my_criterion, train_batch_size, class_num):        super(BuildTrainNetwork, self).__init__()        self.network = my_network        self.criterion = my_criterion        self.print = P.Print()        # Initialize self.output        self.output = mindspore.Parameter(Tensor(np.ones((train_batch_size,                         class_num)), mindspore.float32), requires_grad=False)    def construct(self, input_data, label):        output = self.network(input_data)        # Get the network output and assign it to self.output        self.output = output        loss0 = self.criterion(output, label)        return loss0class TrainOneStepCellV2(TrainOneStepCell):    '''Build train network.'''    def __init__(self, network, optimizer, sens=1.0):        super(TrainOneStepCellV2, self).__init__(network, optimizer, sens=1.0)    def construct(self, *inputs):        weights = self.weights        loss = self.network(*inputs)        # Obtain self.network from BuildTrainNetwork        output = self.network.output        sens = P.Fill()(P.DType()(loss), P.Shape()(loss), self.sens)        # Get the gradient of the network parameters        grads = self.grad(self.network, weights)(*inputs, sens)        grads = self.grad_reducer(grads)        # Optimize model parameters        loss = F.depend(loss, self.optimizer(grads))        return loss, output    # Construct modelmodel_constructed = BuildTrainNetwork(net, loss_function, TRAIN_BATCH_SIZE, CLASS_NUM)model_constructed = TrainOneStepCellV2(model_constructed, opt)3 训练并验证（低阶API）和PyTorch中类似，采用低阶API进行网络训练并验证。详细步骤如下：class CorrectLabelNum(nn.Cell):    def __init__(self):        super(CorrectLabelNum, self).__init__()        self.print = P.Print()        self.argmax = mindspore.ops.Argmax(axis=1)        self.sum = mindspore.ops.ReduceSum()    def construct(self, output, target):        output = self.argmax(output)        correct = self.sum((output == target).astype(mindspore.dtype.float32))        return correctdef train_net(model, network, criterion,     epoch_max, train_path, val_path,     train_batch_size, val_batch_size,     repeat_size):        """define the training method"""    # Create dataset    ds_train, steps_per_epoch_train = create_dataset(train_path,         do_train=True, batch_size=train_batch_size, repeat_num=repeat_size)    ds_val, steps_per_epoch_val = create_dataset(val_path, do_train=False,                batch_size=val_batch_size, repeat_num=repeat_size)    # CheckPoint CallBack definition    config_ck = CheckpointConfig(save_checkpoint_steps=steps_per_epoch_train,                                 keep_checkpoint_max=epoch_max)    ckpoint_cb = ModelCheckpoint(prefix="train_resnet_cifar10",                                 directory="./", config=config_ck)    # Create dict to save internal callback object's parameters    cb_params = _InternalCallbackParam()    cb_params.train_network = model    cb_params.epoch_num = epoch_max    cb_params.batch_num = steps_per_epoch_train    cb_params.cur_epoch_num = 0    cb_params.cur_step_num = 0    run_context = RunContext(cb_params)    ckpoint_cb.begin(run_context)    print("============== Starting Training ==============")    correct_num = CorrectLabelNum()    correct_num.set_train(False)        for epoch in range(epoch_max):        print(" Epoch:", epoch+1, "/", epoch_max)        train_loss = 0        train_correct = 0        train_total = 0          for _, (data, gt_classes) in enumerate(ds_train):            model.set_train()            loss, output = model(data, gt_classes)            train_loss += loss            correct = correct_num(output, gt_classes)            correct = correct.asnumpy()            train_correct += correct.sum()            # Update current step number            cb_params.cur_step_num += 1            # Check whether to save checkpoint or not            ckpoint_cb.step_end(run_context)                    cb_params.cur_epoch_num += 1        my_train_loss = train_loss/steps_per_epoch_train        my_train_accuracy = 100*train_correct/(train_batch_size*                                steps_per_epoch_train)        print('Train Loss:', my_train_loss)        print('Train Accuracy:', my_train_accuracy, '%')                print('evaluating {}/{} ...'.format(epoch + 1, epoch_max))        val_loss = 0        val_correct = 0        for _, (data, gt_classes) in enumerate(ds_val):            network.set_train(False)            output = network(data)            loss = criterion(output, gt_classes)            val_loss += loss            correct = correct_num(output, gt_classes)            correct = correct.asnumpy()            val_correct += correct.sum()        my_val_loss = val_loss/steps_per_epoch_val        my_val_accuracy = 100*val_correct/(val_batch_size*steps_per_epoch_val)        print('Validation Loss:', my_val_loss)        print('Validation Accuracy:', my_val_accuracy, '%')    print("--------- trains out ---------")4 运行脚本启动命令：python MindSpore_1P_low_API.py --data_path=xxx --epoch_num=xxx在开发环境的Terminal中运行脚本，可以看到网络输出结果：注：由于高阶API采用数据下沉模式进行训练，而低阶API不支持数据下沉训练，因此高阶API比低阶API训练速度快。性能对比：低阶API: 2000 imgs/sec ；高阶API: 2200 imgs/sec详细代码请见附件。

1 模型测试在训练完成之后，需要测试模型在测试集上的表现。依据模型评估方式的不同，分以下两种情况1.评估方式在MindSpore中已实现MindSpore中提供了多种Metrics方式：Accuracy、Precision、Recall、F1、TopKCategoricalAccuracy、Top1CategoricalAccuracy、Top5CategoricalAccuracy、MSE、MAE、Loss 。在测试中调用MindSpore已有的评估函数，需要定义一个dict，包含要使用的评估方式，并在定义model时传入，后续调用model.eval()会返回一个dict，内容即为metrics的指标和结果。...def test_net(network, model, test_data_path, test_batch):    """define the evaluation method"""    print("============== Start Testing ==============")    # load the saved model for evaluation    param_dict = load_checkpoint("./train_resnet_cifar10-1_390.ckpt")    #load parameter to the network    load_param_into_net(network, param_dict)    #load testing dataset    ds_test = create_dataset(test_data_path, do_train=False,                             batch_size=test_batch)    acc = model.eval(ds_test, dataset_sink_mode=False)    print("============== test result:{} ==============".format(acc))if __name__ == "__main__":    ...    net = resnet()    loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True,                                 reduction='mean')    opt = nn.SGD(net.trainable_params(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)    metrics = {    'accuracy': nn.Accuracy(),    'loss': nn.Loss()    }    model = Model(net, loss, opt, metrics=metrics)    test_net(net, model_constructed, TEST_PATH, TEST_BATCH_SIZE)2.评估方式在MindSpore中没有实现如果MindSpore中的评估函数不能满足要求，可参考accuracy.py 通过继承Metric基类完成Metric定义之后，并重写clear,updata,eval三个方法即可。通过调用model.predict()接口，得到网络输出后，按照自定义评估标准计算结果。下面以计算测试集精度为例，实现自定义Metrics：class AccuracyV2(EvaluationBase):    def __init__(self, eval_type='classification'):        super(AccuracyV2, self).__init__(eval_type)        self.clear()    def clear(self):        """Clears the internal evaluation result."""        self._correct_num = 0        self._total_num = 0    def update(self, output_y, label_input):        y_pred = self._convert_data(output_y)        y = self._convert_data(label_input)        indices = y_pred.argmax(axis=1)        results = (np.equal(indices, y) * 1).reshape(-1)                self._correct_num += results.sum()        self._total_num += label_input.shape[0]    def eval(self):        if self._total_num == 0:            raise RuntimeError('Accuary can not be calculated')        return self._correct_num / self._total_num        def test_net(network, model, test_data_path, test_batch):    """define the evaluation method"""    print("============== Start Testing ==============")    # Load the saved model for evaluation    param_dict = load_checkpoint("./train_resnet_cifar10-1_390.ckpt")    # Load parameter to the network    load_param_into_net(network, param_dict)    # Load testing dataset    ds_test = create_dataset(test_data_path, do_train=False,                             batch_size=test_batch)    metric = AccuracyV2()    metric.clear()    for data, label in ds_test.create_tuple_iterator():        output = model.predict(data)        metric.update(output, label)    results = metric.eval()    print("============== New Metric:{} ==============".format(results))    if __name__ == "__main__":...    net = resnet()    loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True,                                         reduction='mean')    opt = nn.SGD(net.trainable_params(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)    model_constructed = Model(net, loss, opt)    test_net(net, model_constructed, TEST_PATH, TEST_BATCH_SIZE)2 边训练边验证在训练的过程中，在验证集上测试模型的效果。目前MindSpore有两种方式。1、交替调用model.train()和model.eval() ，实现边训练边验证。...def train_and_val(model, dataset_train, dataset_val, steps_per_train,                     epoch_max, evaluation_interval):    config_ck = CheckpointConfig(save_checkpoint_steps=steps_per_train,                                 keep_checkpoint_max=epoch_max)    ckpoint_cb = ModelCheckpoint(prefix="train_resnet_cifar10",                                 directory="./", config=config_ck)    model.train(evaluation_interval, dataset_train,             callbacks=[ckpoint_cb, LossMonitor()], dataset_sink_mode=True)    acc = model.eval(dataset_val, dataset_sink_mode=False)    print("============== Evaluation:{} ==============".format(acc))if __name__ == "__main__":    ...    ds_train, steps_per_epoch_train = create_dataset(TRAIN_PATH,             do_train=True, batch_size=TRAIN_BATCH_SIZE, repeat_num=1)    ds_val, steps_per_epoch_val = create_dataset(VAL_PATH, do_train=False,                batch_size=VAL_BATCH_SIZE, repeat_num=1)    net = resnet()    loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True,                                     reduction='mean')    opt = nn.SGD(net.trainable_params(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)    metrics = {    'accuracy': nn.Accuracy(),    'loss': nn.Loss()    }    net = Model(net, loss, opt, metrics=metrics)for i in range(int(EPOCH_MAX / EVAL_INTERVAL)):train_and_val(net, ds_train, ds_val, steps_per_epoch_train,                         EPOCH_MAX, EVAL_INTERVAL)2、MindSpore通过调用model.train接口，在callbacks中传入自定义的EvalCallBack实例，进行训练并验证。class EvalCallBack(Callback):        def __init__(self, model, eval_dataset, eval_epoch, result_evaluation):        self.model = model        self.eval_dataset = eval_dataset        self.eval_epoch = eval_epoch        self.result_evaluation = result_evaluation    def epoch_end(self, run_context):        cb_param = run_context.original_args()        cur_epoch = cb_param.cur_epoch_num        if cur_epoch % self.eval_epoch == 0:            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)            self.result_evaluation["epoch"].append(cur_epoch)            self.result_evaluation["acc"].append(acc["accuracy"])            self.result_evaluation["loss"].append(acc["loss"])            print(acc)if __name__ == "__main__":    ...    ds_train, steps_per_epoch_train = create_dataset(TRAIN_PATH,         do_train=True, batch_size=TRAIN_BATCH_SIZE, repeat_num=REPEAT_SIZE)    ds_val, steps_per_epoch_val = create_dataset(VAL_PATH, do_train=False,                batch_size=VAL_BATCH_SIZE, repeat_num=REPEAT_SIZE)    net = resnet()    loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True,                                             reduction='mean')    opt = nn.SGD(net.trainable_params(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)    metrics = {    'accuracy': nn.Accuracy(),    'loss': nn.Loss()    }    net = Model(net, loss, opt, metrics=metrics)result_eval = {"epoch": [], "acc": [], "loss": []}    eval_cb = EvalCallBack(net, ds_val, EVAL_PER_EPOCH, result_eval)    net.train(EPOCH_MAX, ds_train,             callbacks=[ckpoint_cb, LossMonitor(), eval_cb],             dataset_sink_mode=True, sink_size=steps_per_epoch_train)3 样例代码使用说明本文的样例代码是一个Resnet50在Cifar10上训练的分类网络，采用datasets.Cifar10Dataset接口读取二进制版本的CIFAR-10数据集，因此下载CIFAR-10 binary version (suitable for C programs)，并在代码中配置好数据路径。启动命令：python xxx.py --data_path=xxx --epoch_num=xxx运行脚本，可以看到网络输出结果：详细代码请见附件

在前面几期的介绍中，我们已经学习了Mini-batch梯度下降算法、指数加权平均算法，大家是不是觉得不过瘾，别担心，今天小编一口气带来好几个！废话不多说，我们开干吧~动量梯度下降法动量梯度下降法（Momentum），运行速度总是会快于标准的梯度下降算法，基本的思想就是计算梯度的指数加权平均数，并利用该梯度更新权重。在处理优化成本函数时，如上图所示，红点代表最小值的位置，假设从蓝色点开始梯度下降法，无论是batch还是mini-batch下降法，都需要一步一步计算，需要很多计算步骤，浪费很多时间；但是如果使用较大的学习率（紫色箭头），结果可能又会偏离函数范围，为了避免摆动过大，所以需要选用一个较小的学习率。总体来说，纵向上我们希望学习慢一点；而横向上我们更希望加快学习，快速从左向右移，移向最小值红点。所以使用动量梯度下降法时，需要在第t次迭代的过程中，计算微分dW，db；然后重新赋值权重，减缓梯度下降的幅度；最终我们会发现纵向的摆动平均值接近于零，横向的平均值较大，因此具体计算算法为：两个超参数学习率和参数的设置也是需要注意技巧的，控制着指数加权平均数，常用值为0.9，VdW初始值为0，跟W拥有相同的维数，vdb的初始值也是向量零，和b是同一维数。动量梯度下降法就是这么简单，通常可以用来加快学习算法。RMSprop其实RMSprop算法（root mean square prop）也可以加速梯度下降。假设纵轴代表参数b，横轴代表参数W，可能有W1，W2或者其它参数，这里我们简化一下，暂时使用W表示。RMSprop算法可以一方面减缓b方向的学习，同时不会减缓横轴方向的学习。在第t次迭代中，该算法会计算mini-batch的微分dW，db，保留这个指数加权平均数：更新参数：由于我们在横轴方向希望学习速度快，而在垂直方向希望减缓纵轴上的摆动，所以这就需要SdW相对较小，Sdb相对较大。RMSprop算法的更新过程如图中绿色线部分一样，可以用一个的更大学习率加快学习，但其实dW实际是一个高维度的参数向量，实际使用中需要注意这点。RMSprop均方根算法，将微分先平方，最后使用平方根，同时我们在处理的时候，通常会在分母上加上一个很小的（10-8）以保证算法不会除以0。Adam 优化算法Adam（Adam optimization algorithm）优化算法就很巧妙了，是上述两个算法的结合。1.初始化：；2.在第t次迭代中，用mini-batch梯度下降法计算dW，db；3.计算Momentum指数加权平均数：，；4.RMSprop更新：，；5.偏差修正：，；6.更新W和b：。之前我们已经提过，作为dW的移动平均数，通常选用0.9，超参数推荐使用0.999，设置为10-8，这样我们就可以尝试不同的，看看哪个效果最好啦。Adam算法结合了Momentum和RMSprop梯度下降法，是一种极其常用的学习算法，被证明能有效适用于不同神经网络，适用于广泛的结构。学习率衰减学习率衰减（Learning rate decay）：随时间慢慢减少学习率，我们将之称为学习率衰减。假设使用mini-batch梯度下降法，mini-batch数量选择64或者128个样本，在迭代过程中会有噪音（蓝色线），所以算法不会会真正收敛，只能在附近摆动。但要慢慢减少学习率的话，在初期的时候，学习率较大，学习相对较快；但随着学习率变小，移动步伐也会变慢变小，所以曲线（绿色线）会在最小值附近的一小块区域里摆动，而不是大幅度在最小值附近摆动。学习率衰减一代就要遍历一次数据，拆分不同的mini-batch，第一次遍历训练集叫做第一代，第二次就是第二代，依此类推，将学习率设为（decay-rate称为衰减率，epoch-num为代数，为初始学习率）。当然也可以使用其他公式，比如指数衰减，其中a0是小于1的值，如，学习率呈指数下降。好啦，这次的优化算法就全部介绍到这里啦，尤其需要注意的是参数和公式的理解！下次给大家带来超参数调试的讲解，挥手十分钟再见！

本研究首次对DINO训练的自监督视觉Transformers 对抗攻击的鲁棒性进行了分析。首先，我们评估通过自监督学习的特征是否比通过监督学习学习的特征更能抵御对抗性攻击。然后，我们提出了在潜在空间中攻击所产生的性质。最后，我们评估了三种众所周知的防御策略是否可以增加下游任务的对抗鲁棒性，即使在有限的计算资源下，仅通过微调分类头来提供鲁棒性。这些防御策略是:对抗性训练、集成对抗性训练和专业网络集成。https://www.zhuanzhi.ai/paper/1fd3439a6ac6312d164fc46827f9cbb2

本研究首次对DINO训练的自监督视觉Transformers 对抗攻击的鲁棒性进行了分析。首先，我们评估通过自监督学习的特征是否比通过监督学习学习的特征更能抵御对抗性攻击。然后，我们提出了在潜在空间中攻击所产生的性质。最后，我们评估了三种众所周知的防御策略是否可以增加下游任务的对抗鲁棒性，即使在有限的计算资源下，仅通过微调分类头来提供鲁棒性。这些防御策略是:对抗性训练、集成对抗性训练和专业网络集成。https://www.zhuanzhi.ai/paper/1fd3439a6ac6312d164fc46827f9cbb2

本文将具体介绍如何将PyTorch的代码迁移至MindSpore，并在Ascend芯片上实现单机单卡训练。使用的PyTorch代码为：Resnet50+CIFAR-10的图像分类任务。示例代码：包含PyTorch和MindSpore代码数据集：CIFAR-10MindSpore API主要类别一、训练流程对比介绍由于MindSpore的架构设计不同于PyTorch框架，二者的训练流程以及代码实现也有不同，下图展示了两者的区别。二、训练代码实现2.1 基本参数配置该部分与Pyotrch基本保持一致import argparse if __name__ == "__main__": parser = argparse.ArgumentParser(description='MindSpore CIFAR-10 Example') parser.add_argument('--pre_trained', type=str, default=None, help='Pretrained checkpoint path') parser.add_argument('--data_path', type=str, default=None, help='data_path') parser.add_argument('--epoch_num', type=int, default=200, help='epoch_num') parser.add_argument('--checkpoint_max_num', type=int, default=5, help='Max num of checkpoint') args = parser.parse_args() LR_ORI = 0.01 EPOCH_MAX = args.epoch_num TRAIN_BATCH_SIZE = 128 VAL_BATCH_SIZE = 100 MOMENTUM_ORI = 0.9 WEIGHT_DECAY = 5e-4 CHECKPOINT_MAX_NUM = args.checkpoint_max_num # Data path TRAIN_PATH = args.data_path VAL_PATH = args.data_path2.2 配置运行信息MindSpore通过context.set_context来配置运行需要的信息，譬如运行模式、后端、硬件等信息。该用例中，我们配置使用图模式，并运行在Ascend芯片上。from mindspore import context context.set_context(mode=context.GRAPH_MODE, device_target='Ascend')2.3 数据集加载与处理PyTorch的数据增强方式包括：RandomCrop，RandomHorizontalFlip，Normalize，ToTensor。通过文API映射关系找到PyTorch在MindSpore对应的接口，进行代码迁移，此处使用了c_transforms接口，是基于C++ opencv开发的高性能图像增强模块，因此最后需通过HWC2CHW()将HWC格式转为MindSpore支持的CHW格式。 迁移后的MindSpore数据集加载与处理代码如下:import mindsporeimport mindspore.dataset as dsimport mindspore.dataset.vision.c_transforms as CVimport mindspore.dataset.transforms.c_transforms as C def create_dataset(data_home, do_train, batch_size): # Define dataset if do_train: cifar_ds = ds.Cifar10Dataset(dataset_dir=data_home, num_parallel_workers=8, shuffle=True, usage='train') else: cifar_ds = ds.Cifar10Dataset(dataset_dir=data_home, num_parallel_workers=8, shuffle=False, usage='test') if do_train: # Transformation on train data transform_data = C.Compose([CV.RandomCrop((32, 32), (4, 4, 4, 4)), CV.RandomHorizontalFlip(), CV.Rescale(1.0 / 255.0, 0.0), CV.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), CV.HWC2CHW()]) else: # Transformation on validation data transform_data = C.Compose([CV.Rescale(1.0 / 255.0, 0.0), CV.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), CV.HWC2CHW()]) # Transformation on label transform_label = C.TypeCast(mindspore.dtype.int32) # Apply map operations on images cifar_ds = cifar_ds.map(operations=transform_label, num_parallel_workers=8, python_multiprocessing=True, input_columns="label") cifar_ds = cifar_ds.map(operations=transform_data, num_parallel_workers=8, python_multiprocessing=True, input_columns="image") cifar_ds = cifar_ds.batch(batch_size, num_parallel_workers=8, drop_remainder=True) steps_per_epoch = cifar_ds.get_dataset_size() return cifar_ds, steps_per_epoch定义好后直接在主函数中调用即可# Create dataset ds_train, steps_per_epoch_train = create_dataset(TRAIN_PATH, do_train=True, batch_size=TRAIN_BATCH_SIZE) ds_val, steps_per_epoch_val = create_dataset(VAL_PATH, do_train=False, batch_size=VAL_BATCH_SIZE)MindSpore针对以下三种情况已经做了很好的适配，可参考使用。1.常用数据集加载2.特定格式数据集加载（MindRecord）3.自定义数据集加载2.4 网络定义分析PyTorch网络中所包含的算子，通过API映射关系和MindSpore API，找到MindSpore对应的算子，并构造Resnet网络：MindSpore中使用nn.Cell构造网络结构。在Cell的__init__函数内，定义需要使用的算子。然后在construct函数内将定义好的算子连接起来，最后将输出通过return返回。构造resnet的block单元注： 为了保证权重初始化与PyTorch一致，故定义了_conv2d和_dense函数。import mathimport mindsporeimport mindspore.nn as nnfrom mindspore.ops import operations as P EXPANSION = 4 def _conv2d(in_channel, out_channel, kernel_size, stride=1, padding=0): scale = math.sqrt(1/(in_channel*kernel_size*kernel_size)) if padding == 0: return nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode='same', weight_init=mindspore.common.initializer.Uniform(scale=scale)) else: return nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=stride, padding=padding, pad_mode='pad', weight_init=mindspore.common.initializer.Uniform(scale=scale)) def _dense(in_channel, out_channel): scale = math.sqrt(1/in_channel) return nn.Dense(in_channel, out_channel, weight_init=mindspore.common.initializer.Uniform(scale=scale), bias_init=mindspore.common.initializer.Uniform(scale=scale)) class ResidualBlock(nn.Cell): def __init__(self, in_planes, planes, stride=1): super(ResidualBlock, self).__init__() self.conv1 = _conv2d(in_planes, planes, kernel_size=1) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = _conv2d(planes, planes, kernel_size=3, stride=stride, padding=1) self.bn2 = nn.BatchNorm2d(planes) self.conv3 = _conv2d(planes, EXPANSION*planes, kernel_size=1) self.bn3 = nn.BatchNorm2d(EXPANSION*planes) self.shortcut = nn.SequentialCell() if stride != 1 or in_planes != EXPANSION*planes: self.shortcut = nn.SequentialCell( _conv2d(in_planes, EXPANSION*planes, kernel_size=1, stride=stride), nn.BatchNorm2d(EXPANSION*planes)) self.relu = nn.ReLU() self.add = P.Add() def construct(self, x_input): out = self.relu(self.bn1(self.conv1(x_input))) out = self.relu(self.bn2(self.conv2(out))) out = self.bn3(self.conv3(out)) identity = self.shortcut(x_input) out = self.add(out, identity) out = self.relu(out) return out构建主干网络ResNet网络中有大量的重复结构，可以使用循环构造多个Cell实例并通过SequentialCell来串联，减少代码重复。在construct函数内将定义好的算子连接起来，最后将网络输出通过return返回。主干网络代码如下：class ResNet(nn.Cell): def __init__(self, num_blocks, num_classes=10): super(ResNet, self).__init__() self.in_planes = 64 self.conv1 = _conv2d(3, 64, kernel_size=3, stride=1, padding=1) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU() self.layer1 = self._make_layer(64, num_blocks[0], stride=1) self.layer2 = self._make_layer(128, num_blocks[1], stride=2) self.layer3 = self._make_layer(256, num_blocks[2], stride=2) self.layer4 = self._make_layer(512, num_blocks[3], stride=2) self.avgpool2d = nn.AvgPool2d(kernel_size=4, stride=4) self.reshape = mindspore.ops.Reshape() self.linear = _dense(2048, num_classes) def _make_layer(self, planes, num_blocks, stride): strides = [stride] + [1]*(num_blocks-1) layers = [] for stride in strides: layers.append(ResidualBlock(self.in_planes, planes, stride)) self.in_planes = EXPANSION*planes return nn.SequentialCell(*layers) def construct(self, x_input): x_input = self.conv1(x_input) out = self.relu(self.bn1(x_input)) out = self.layer1(out) out = self.layer2(out) out = self.layer3(out) out = self.layer4(out) out = self.avgpool2d(out) out = self.reshape(out, (out.shape[0], 2048)) out = self.linear(out) return out对外调用接口def resnet_50(): return ResNet([3, 4, 6, 3])下图展示了PyTorch与MindSpore在定义一个小的CNN网络上的差异:2.5 定义损失函数和优化器PyTorch损失函数和优化器：# Define network net = resnet_50() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') net = net.to(device) # Define the loss function criterion = torch.nn.CrossEntropyLoss() # Define the optimizer optimizer = torch.optim.SGD(net.parameters(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)迁移后的MindSpore的损失函数和优化器：# Define network net = resnet_50() # Define the loss function loss = nn.loss.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean') # Define the optimizer opt = nn.SGD(net.trainable_params(), LR_ORI, MOMENTUM_ORI, WEIGHT_DECAY)2.6 构建模型MindSpore推荐使用mindspore.Model接口对网络进行封装，内部会自动构建训练流程。需要将定义好的网络原型、损失函数、优化器和metrics传入Model接口，同时为了便于模型评估，MindSpore中提供了多种Metrics，如Accuracy、Precision、Recall、F1等。注：此处为了发挥Ascend芯片的高性能算力，开启了amp_level="O3"。from mindspore import Model # Create train model metrics = {'accuracy': nn.Accuracy(), 'loss': nn.Loss()} model = Model(net, loss, opt, metrics=metrics, amp_level="O3")2.7 训练并验证MindSpore通过调用Model.train接口，并在callbacks中传入自带的ModelCheckpoint、LossMonitor和自定义的EvalCallBack、PrintFps实例，进行训练并验证。import timefrom mindspore.train.callback import Callback, ModelCheckpoint, LossMonitorfrom mindspore.train.callback import CheckpointConfig class EvalCallBack(Callback): def __init__(self, eval_model, eval_dataset, eval_per_epoch): self.eval_model = eval_model self.eval_dataset = eval_dataset self.eval_per_epoch = eval_per_epoch def epoch_end(self, run_context): cb_param = run_context.original_args() cur_epoch = cb_param.cur_epoch_num if cur_epoch % self.eval_per_epoch == 0: acc = self.eval_model.eval(self.eval_dataset, dataset_sink_mode=False) print(acc) class PrintFps(Callback): def __init__(self, step_num, start_time): self.step_num = step_num self.start_time = start_time self.end_time = time.time() def epoch_begin(self, run_context): self.start_time = time.time() def epoch_end(self, run_context): self.end_time = time.time() cb_param = run_context.original_args() cur_epoch = cb_param.cur_epoch_num fps = self.step_num / (self.end_time - self.start_time) print("Epoch:{}, {:.2f}imgs/sec".format(cur_epoch, fps)) # CheckPoint CallBack definition config_ck = CheckpointConfig(save_checkpoint_steps=steps_per_epoch_train, keep_checkpoint_max=CHECKPOINT_MAX_NUM) ckpoint_cb = ModelCheckpoint(prefix="train_resnet_cifar10", directory="./checkpoint/", config=config_ck) # Eval CallBack definition EVAL_PER_EPOCH = 1 eval_cb = EvalCallBack(model, ds_val, EVAL_PER_EPOCH) train_data_num = steps_per_epoch_train * TRAIN_BATCH_SIZE # FPS CallBack definition init_time = time.time() fps_cb = PrintFps(train_data_num, init_time) # Train print("============== Starting Training ==============") model.train(EPOCH_MAX, ds_train, callbacks=[LossMonitor(), eval_cb, fps_cb, ckpoint_cb], dataset_sink_mode=True, sink_size=steps_per_epoch_train)三、运行启动命令：python MindSpore_1P.py --epoch_num=xxx --data_path=xxx在Terminal中运行脚本，可以看到网络输出结果： 相关代码请点击附件下载：

最近在ModelArt上申请了一个MindSpore版本为1.5.1的昇腾设备，在modelZoo上想找个yolov4来训练以下自己的数据集，但是发现MindSpore1.5的yolov4预训练权重需要自己进行训练，有没有MindSpore1.5版本的CSPDrakNet预训练权重呀，或者 1.5 的能不能用1.6的预训练权重？之前在1.6上用SSD模型跑过自己的数据集，然后再310上的1.7转om是算子报错了，那1.6的算子和1.5之间的差距是否会影响到CSP的预训练权重，可以直接提供一个1.5的CSP权重嘛

【功能模块】Cascade_RCNN代码来源https://www.hiascend.com/zh/software/modelzoo/models/detail/2/6b3530aa27304214972f593383b5eda3使用coco数据集【操作步骤&问题现象】执行bash ./test/train_performance_1p.sh【截图信息】【日志信息】（可选，上传日志内容或者附件）

# PicoDet模型在昇腾310上的部署 ## 1、简介： 本项目是基于昇腾310推理芯片部署PicoDet模型的应用，实现目标检测的功能。项目链接： [ Ascend310-PicoDet](https://gitee.com/dzm9999/ascend310-pico-det) 进行推理功能的测试方法可以参考项目中的readme文件 关于PicoDet模型可以参考： [PaddleDetection-PicoDet](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.3/configs/picodet) ## 2、实现流程： 本项目参考Paddle2ONNX中PicoDet模型在onnxruntime下的部署流程，添加了使用昇腾310进行推理的代码，整体流程符合典型的目标检测应用的流程，即： 获取图片--》预处理--》推理--》后处理--》保存图片 使用cv2.imread读取图片后，对图片进行等比例缩放和补边，调整图片的尺寸满足模型的输入要求，进行归一化，通道转换等操作后，使用acl.model进行模型相关的操作，并进行推理。之后通过nms，坐标转换等后处理操作将推理得到的数据转换为实际图片上的预测框坐标和预测种类的置信度，最后将结果保存为图片文件。 ## 3、效果展示： 两图分别为在昇腾310上的推理结果和在pc上使用onnx模型进行推理的结果。在模型输入为320x320，FP16的情况下，昇腾310推理耗时为4ms   ## 4、后续优化 本项目中仍有很多可以优化的点，如预处理的实现使用的是opencv，如替换成dvpp+aipp的实现方式，可能对前处理速度有较大提升。本项目参考了以下项目： [Paddle2ONNX](https://github.com/PaddlePaddle/Paddle2ONNX) [AclLite](https://gitee.com/ascend/samples/tree/master/python/common/acllite)

学习目标：目录DEvOps的五要素DEvOps的生命周期

我新手，想搞纯国产的AI软硬件，求推荐个能训练和推理的昇腾开发板，能跑MindSpore就行。请大佬们指教。谢谢。

【功能模块】对mask_tensor进行优化【操作步骤&问题现象】1、定义的优化器：self.opt = nn.Adam(params=[Parameter(default_input=self.mask_tensor,name="mask", requires_grad=True)], learning_rate=0.01, weight_decay=0.0001)2、自定义的trainonestep：class TrainOneStepCell_3(nn.Cell): """自定义训练网络""" def __init__(self, network, optimizer, sens=1.0): """入参有三个：训练网络，优化器和反向传播缩放比例""" super(TrainOneStepCell_3, self).__init__(auto_prefix=False) self.network = network self.network.set_grad() self.optimizer = optimizer self.weights = self.optimizer.parameters self.grad = ops.composite.GradOperation(get_all=True, sens_param=False) def construct(self, input_tensor,mask_tensor,ref): loss = self.network(input_tensor,mask_tensor,ref) grads = self.grad(self.network)(input_tensor,mask_tensor,ref) # loss = ops.depend(loss, self.optimizer(grads[1])) self.optimizer(grads[1]) return grads,loss【截图信息】报错信息：【日志信息】（可选，上传日志内容或者附件）

近日，上海交通大学人工智能研究院杨小康教授、王韫博助理教授指导的AI+Science研究团队的成果《NeuroFluid: Fluid Dynamics Grounding with Particle-Driven Neural Radiance Fields》被国际顶级机器学习会议ICML 2022收录。论文所提出的“神经流体（NeuroFluid）”模型，利用基于神经隐式场的人工智能可微渲染技术，将流体物理仿真看作求解流体场景三维渲染问题的逆问题——从流体场景的一段多视角表观图像中，即可反推出流体内部的运动规律。这项成果为计算流体动力学、多粒子动力学系统研究开辟了一种人工智能新途径。论文链接: https://www.zhuanzhi.ai/paper/ddad8ebf86c68fae5d98015f1bc671f7代码地址: github.com/syguan96/NeuroFluid项目主页: syguan96.github.io/NeuroFluid/流体运动研究是重要的自然科学基础研究领域，在航空航天、大气、海洋、航运、能源、建筑、环境等众多领域有着广泛应用。在传统研究方法中，求解流体运动（例如速度场）需要首先在理论上精确刻画流体的动力学模型，并结合微分方程、数值分析对模型求解。但是通常对于复杂问题（例如湍流），人们很难用数学物理方程进行描述，复杂流体的Navier-Stokes方程是世界级千禧难题，至今依然没被很好解决。现有基于深度学习的方法通常从拉格朗日视角描述流体，即流体被看作由许多粒子组成，通过测定和约束每个粒子的运动即可测定和改变流体的运动。但是大多数方法通常要求已知流体的物理属性（例如粘性），并且需要粒子的运动信息（位置和速度）作为训练数据，这在真实场景中几乎不太可能。针对流体力学模型难以刻画和求解的问题，本文提出一种名为NeuroFluid的神经网络方法，实现流体动态反演（fluid dynamics grounding），即根据稀疏视角下对流体的2D表观视觉观察，推断推流体内在的3D物理运动状态，例如粒子的速度和位置等。如图2所示，NeuroFluid包含基于神经网络的流体粒子状态转移模型（Particle Transition Model）和由粒子驱动的神经网络渲染器（PhysNeRF），并将二者整合到一个端到端的联合优化框架中。优化过程包含三个阶段：1. 模拟：粒子状态转移模型根据初始状态（可用立体视觉方法粗估）预测流体粒子在后续时刻的运动轨迹；2. 渲染：神经网络渲染器PhysNeRF（图2右）根据粒子的几何信息将模拟结果渲染成图像；3. 比对：渲染图像和真实图像比对，计算误差，通过梯度反向传递优化模型参数。图2. NeuroFluid的训练过程（图左）及PhysNeRF的渲染示意（图右）本文使用的流体数据（HoneyCone、WaterCube、WaterSphere）具有不同的物理属性（如密度、粘度、颜色）或初始状态（如流体粒子位置、整体形态）。下列的实验从粒子动态反演、未来状态预测、新视角图像渲染、PhysNeRF域外场景泛化，验证了NeuroFluid的有效性。1实验1：流体粒子动态反演本实验计算从图像反演的粒子位置与真实粒子位置之间的距离误差（Pred2GT distance），作为评价指标。图3展示了NeuroFluid与流体粒子预测的有监督方法DLF[1]的数值结果对比，显然，NeuroFluid从视频中反演的流体粒子状态比DLF（用粒子运动速度和位置作为训练数据）更准确。图4对模型的粒子状态推断结果做了可视化，注意到随着时间的推移，NeuroFluid相比基线模型，其反演结果运动更加自然，能更好地匹配真实流体动态。图3. NeuroFluid（浅蓝色）在三个测试集上关于流体粒子位置的反演结果，相比流体粒子仿真的有监督模型DLF，NeuroFluid从图像推理流体内部状态，明显具有更好的准确性图4. NeuroFluid（第三行）在WaterCube场景中对流体粒子位置的推断结果，图中第一行为生成对应观测图像序列时所使用的“真实”流体粒子位置2实验2：流体未来状态预测在有效学习了流体的粒子状态转移模型后，可以很方便地实现预测流体在未来时刻的运动状态。如图5所示，本实验评估未来十个时刻内，模型预测的粒子位置与真实情况的误差。结果表明，NeuroFluid能够通过视觉观测学习流体运动的规律，推演合理的流体未来动态。图5. 流体未来状态预测误差。其中，DLF*表示将基线模型在与测试场景物理属性相近的数据上进行微调；DLF+表示将基线模型直接在测试场景上进行微调3实验3：流体场景的新视角图像渲染为了验证PhysNeRF渲染器的有效性，本实验在新视角合成（novel view synthesis）的任务上，广泛对比了各种基于神经隐式场的可微渲染技术，包括NeRF[2]，NeRT-T （即NeRF+Time Index）, D-NeRF[3]和Li et al. (2022)[4]等。如图6所示，在输入了粒子几何信息的情况下，NeuroFluid的渲染结果不仅在动态上与目标结果的匹配度最高，而且可以更好地渲染出流体的细节（如溅起的水珠）。图6. 新视角合成结果对比，左起第一列为新视角下的目标图像4实验4:  域外场景泛化PhysNeRF的基本假设是流体图像渲染应以粒子状态为驱动，故而应具有不同粒子分布下的强大泛化能力。为验证其泛化能力，本实验在使用有限的场景训练好PhysNeRF渲染器后，在测试时改变了流体的初始形貌，如图7所示，该几何形状为计算机图形学经典的Stanford Bunny。值得注意的是，在没有用Stanford Bunny数据对模型进行训练微调的情况下，PhysNeRF较为精细地渲染出了流体的表面细节。图7. PhysNeRF在域外流体场景（训练所未见）上的泛化效果总结：上海交通大学AI+Science研究团队所提出的NeuroFluid模型能成功拟合符合视觉观测的流体运动转移规律，从视觉表观观测反演流体内在运动，有望为传统流体力学无法准确刻画的复杂流体运动（如湍流）提供一种全新的计算范式。

在现代监督学习中，如何在训练数据稀缺的新领域学习预测模型是一个日益严峻的挑战。这激励开发领域适应方法，利用已知领域(源领域)中的知识，以适应具有不同概率分布的新领域(目标领域)。当源和目标域处于异构特征空间(称为异构域适应(HDA))时，这就变得更具挑战性。虽然大多数HDA方法利用数学优化将源数据和目标数据映射到一个共同的空间，但它们具有较低的可转移性。神经表征已被证明更具可转移性;然而，它们主要是为同类环境设计的。基于区域适应理论，我们提出了一种新的框架——异构对抗性神经域适应(Heterogeneous Adversarial Neural domain adaptation, HANDA)，以有效地最大化异质性环境下的可迁移性。HANDA在统一的神经网络体系结构中进行特征和分布对齐，通过对抗核学习实现域不变性。在主要的图像和文本电子商务基准测试中，我们进行了三个实验，以评估与最先进的HDA方法相比的性能。HANDA显示了统计上显著的预测性能改善。HANDA的实际效用在真实世界的暗网在线市场中得到了展示。HANDA是电子商务应用领域成功适应的重要一步。 https://arxiv.org/pdf/2205.07853.pdf

【摘要】 将通过对ModelArts、盘古大模型、ModelBox产品技术的解读，帮助开发者更好的了解AI开发生产线。本文分享自华为云社区《【大厂内参】第16期：华为云AI开发生产线，破解AI全流程开发难题》，作者：华为云社区精选 。近日，华为云对AI开发生产线进行服务升级，帮助各行各业的软件开发更简单快速地完成SaaS化，在云上创造更大价值。AI开发生产线，通过 ModelArts 和 AI Gallery , 支持AI开发运维的DevOps全流程。通过预集成盘古大模型和丰富的AI资产，让开发者实现从数据标注、数据处理、模型训练、到部署上线、模型调优等环节全流水线自动衔接，大幅提升效率。1.基于行业算法套件的ModelArts云原生AI开发最佳实践在AI开发的探索阶段，选择合适的环境、便利的工具、按需的算力、一键可运行的算法资源是我们最重要的因素。在环境和算力方面，使用ModelArts提供云化Notebook，配合弹性按需算力资源能力，可以快速地让我们拿到一个带AI计算资源的环境。在算法方面，面向特定领域问题的算法解法集合、AI算法套件，可以让我们快速的在算法间切换，找到合适的并且具备实际应用的自研及开源算法，通过订阅和选择的方式，可以在ModelArts上一键式的运行。在工具方面，我们基于云化的Notebook提供了参数化的开发模式，让你的探索变得更便捷高效。1.1选择合适的AI开发套件，让你的开发事半功倍1.1.1云原生Notebook华为云会选择Notebook作为线上AI开发与探索的首选工具，其优势在于可贯穿整个AI开发探索生命周期，从数据的处理到模型的开发以及验证和调测，都是能够全部覆盖的。Notebook可提供交互式的编程体验，探索过程中的可视化要求，可以快速地进行结果的分享与重现。如上图“Kaggle在2021年机器学习开发者调研数据”所示，可以看到在IDE的流行度里面，Notebook占据很重要的位置。纵观整体业界趋势，各个云化AI开发厂商还是以JupyterLab底座+插件的方式演进，主打资源免费、协作、社交化。ModelArts云化Notebook也是基于此趋势进行演进，并且提供丰富的差异化场景能力。资源切换、CodeLab、云上云下插件等，贴近用户使用习惯，提升AI开发效率。1.1.2算法开发套件我们知道，在AI的算法方面，需要去寻找匹配我们业务场景的合适算法，并且需要进行环境和算法之间的适配开发，以及算法相关参数的调优。ModelArts提供的算法套件是面向一类算法问题解的集合，是针对特定的行业、领域预训练模型、算法实现及数据集。以简单易用为基础正对云边端场景的不同需求，提供相应的内容支持。目前，华为云AI算法套件是通过自研+社区两个方面，确保算法的丰富度。自研方面，结合丰富的真实AI开发经验，提供领域预训练模型、算法实现及数据集。目前已经在图像分类、目标检测、视觉分类、姿态预估等多个领域提供相关的内容，并且后续会持续丰富。用户可以在AI Gallery上一键订阅，在ModelArts上一键运行，提升用户的AI开发和探索效率。社区方面，对于社区的主流算法套件完成了非侵入式的适配，例如MMDetection、MMOCR、MMSegmentation等算法套件，可以像加载自研算法套件一样，在ModelArts中快速加载一键运行。1.1.3算法调优有了工具和算法，接下来就是算法开发的探索和调优。华为云基于ModelArts提供的基于Notebook的参数化、图形化、交互式的能力加速开发过程，帮助开发者在数据处理、模型调优以及模型预测方面进行可视化的操作，低门槛完成多种场景的AI算法开发与应用，配套提供的算法套件可以更加高效进行AI开发。上图是Notebook的Excel，用户可以进行参数化的定义数据处理过程和训练过程，可以图形化查看训练结果，有表格，而不是之前的大篇幅的日志，还可以进行交互式的进行结果调测。不仅如此，Notebook还提供了丰富的基础组件和组件定义能力，用户可以根据自己的使用需求和习惯定义个性化的插件。在开发的资源和算力方面，ModelArts云原生AI开发资源与算力构建在开放的华为云云原生平台之上，基于底层应用、开放自主的相关基础云原生能力，方便开发者按需，低成本，灵活获取到可用的资源和算力。1.2标准化的开发工具，云上云下协同从前面的介绍大家可以了解到，对于华为云AI开发工程师，在AI开发的实验原型和探索阶段是基于ModelArts提供的serverless化的Notebook的交互式参数化能力，配合弹性按需算力、资源和环境，以及丰富的算法套件，帮助我们加速实验原型的探索及开发。面对具体AI团队开发及应用落地时，需要涉及多人和多阶段配合完成从数据处理、算法开发和调优，到模型训练、推理开发及测试，并且在后续运行中涉及反复的迭代，怎么样可以高效地完成这项工作。借鉴传统软件开发经验和实践，华为云通过工程化的AI开发模式，从工具到开发标准，再到代码化工程管理能力，助力开发团队协同完成AI开发及应用落地。在工具方面，为了更加匹配通用的IDE工具使用习惯，使用ModelArts提供VSCode\PyCharm插件，就可以在自己的本地VSCode\PyCharm上进行代码开发，使用插件远程连接云上资源进行远程开发调测，并且可以调用模型训练、模型部署等能力。通过定义AI工程框架，来让AI开发标准化，这个标准化的工程框架是实践的总结和积累。使用ModelArts提供的标准化AI开发工程模板在模板中对于数据、算法、推理等各个环节的结构进行定义，并且还提供了CLI工程脚手架，通过代码与命令的方式与平台功能相结合，全流程完成工程化的AI开发。用户可以基于我们提供的工程结构定义，分工协同，完成不同内容的开发。上图为ModelArts提供的标准化工程结构，可以通过代码化方式完成AI过程、步骤、行为、资源等定义，并且通过代码仓统一管理。例如：用户可以定义workflow、镜像、训练、作业、应用部署等，并且配合统一的资产管理进行工程化的AI开发。前面介绍了云上开发工具的能力，云上的IDE与传统的IDE在能力上还是存在差距的，所以为了更加匹配开发者通用IDE工具的使用习惯，ModelArts使用了基于VSCode\PyCharm+ModelArts插件，满足本地化开发及调测诉求。面对稀缺的GPU资源的诉求，通过远程连接云上资源的能力，打造本地开发远程资源按需使用的能力，插件提供一键式的安装配置等能力，方便我们开发者的使用。后续ModelArts也会提供更加沉浸式的AI开发能力，包含AI计算资源、云上存储预置AI镜像，让用户体验到云上资源便利的同时，也带来本地开发的顺畅感。在远程插件上，可以调用云上的开发、数据、训练、推理等能力，以及提供的工程相关的所有AI开发能力，真正满足一个团队不同用户的诉求。1.3AI Gallery构建丰富活跃的AI生态在正式的AI开发项目中，我们会面临更多的困难和问题。AI Gallery是在ModelArts的基础上构建了开发者生态社区，丰富及活跃的生态是AI开发的基础和推动力。在AI Gallery中，不仅提供了Notebook代码样例、数据集、算法套件、模型等AI数字资产；而且还有学习、实践、交流等板块，方便不同诉求的用户交流。并且在资产方面提供分享和订阅能力，方便AI资产持续更新和迭代。我们希望开发者沉淀更多的资产，帮助更多的AI开发者，提升大家的开发效率，加速AI产业的发展。传统软件开发完成后就是交付运维，AI的软件开发交付后不仅仅是交付运维，还有面临持续的数据更新、模型迭代、难例挖掘，这些流程应该是标准化可信的，并且与开发流程解偶，所以ModelArts提供了工作流的能力。工作流是基于实际业务场景开发的，用于部署AI应用流水线工具，把已经完成好的AI开发业务场景，通过ModelArts Python SDK进行编排和开发，将数据处理、模型训练、模型部署等能力进行编码，然后把流水线发布给业务应用人员。对于应用者来说不一定需要了解整个开发实现细节，他们只需要了解流水线的机制，以及需要存在变化的内容即可。例如：数据的增强、更新或者模型的参数变化，就可以方便地进行模型迭代、上线，这样让开发和运行分离，提高后续业务迭代的效率。综上我们可以看出，ModelArts 致力打造一站式的AI开发平台，让AI开发变得简单、高效。华为云从AI开发全流程出发，在分析设计算法模型探索和实验模型集成与开发以及AI应用运维上提供高效、便捷的能力，并且结合华为云丰富的实践经验，沉淀更多的标准化AI开发流水线，为AI开发者提供更多更好的服务。2.华为云盘古大模型，开启AI工业化开发2025年，企业对AI的采用率将达到86%。所以，AI走进企业的生产核心系统创造更大价值是大势所趋。但与之相对的是，封闭的作坊式AI开发已经无法满足行业高效、高质量的数字化转型需求。因为当企业有了AI需求以后，就需要独立的创建一个场景。在这个场景中，企业要投入专家和开发人员，来针对这个场景去进行专门的研发。这会导致AI应用的开发效率低下，并且它的开发经验，包括产生的一些资产也是无法得到有效积累。针对这样的情况，华为提出了 盘古大模型 。2.1什么是华为盘古大模型华为云盘古大模型，是把海量的数据知识存储在超大型的神经网络中，针对定制化的需求，只需要将这些需求固化成一些流水线。在这个过程中，由于不同的流水线之间大部分的流程都是一样的，仅仅只有小部分的操作或者场景专有的知识是有所不同的，所以就可以把这些知识或者操作像搭积木一样，放在在这个流水线上面进行开发。这样的开发模式比起作坊式的开发模式，就会更加的节省时间和人力。在实际测试当中，盘古大模型进入企业生产系统以后，效率提升是非常明显的。原来需要十个人所做的事情，现在只要一个人就可以把它做完，效率的提升达到十倍以上。2.2五大盘古大模型应用在千行百业为了更好地针对不同领域方面，在盘古大模型中，有视觉、NLP(自然语言处理)、多模态、Graph和科学计算等五个领域的大模型。在不同的行业。场景下，如金融风控、工业质检、时尚设计、案件审核和智慧育种等场景下，设置场景化模型。这些场景化模型都可以适配盘古大模型，最后应用在不同的行业案例中，如违规风险识别、布料质检、流行元素标注等等应用。盘古大模型是通过把算力、研发成本前置到华为云侧，如华为云每年会消耗英伟达V100GPU超过4000张、使用相当于4TB清洗后纯文本数据和10亿张图片去进行训练，配备大量的工程师，经过多年的积累研发了大模型系统，这个大模型系统及可以帮助业界把成本大大减少和降低，不用在耗时耗力重复性的开发算法及模型，应用大模型从而快速的进行AI开发为了让大家更好的认识和熟悉大模型，接下来将为大家展示大模型在不同行业中的应用。2.2.1CV大模型在铁路TFDS进行未知的故障预测的场景中：一辆列车行驶路途中，有个摄像头架设在一个固定地点，通过拍摄列车上各种不同视角不同位置的图像后，快速的去判断列车是否有故障。由于这些故障出现次数较少，故障类型多、拍摄图片质量差等原因，因此很多情况下小模型无法取得很好的应用。很多情况下，工程师要针对每个故障去适配一个小模型，成本就非常高，更不要说未知故障的预测了。通过盘古大模型，可以用一个或者少数几个大模型去适配铁路TFDS中的100多种不同的故障场景。最终保证故障的召回率达到90%，未知故障预测发现率提升1倍以上，同时还能保证单张图片的识别时间小于4ms。2.2.2NLP大模型关于NLP大模型，为大家介绍的是最高检应用项目。在这个项目当中，从最高检获取文本，对法律文书文本进行分析，去理解其中所代表的内容。比如，某一项法律为什么应用在这个判决的这个地方，这中间包含了哪些原因等等。如果是传统小模型，需要适配数据再去适配不同的案例，这就导致时间较长。盘古大模型已经在预训练过程中积累了大量NLP方面的知识，所以基于盘古大模型就可以在很短的时间内，把测试结果不断地从开始的73%提升到最后的测试结果92%，也是高效地完成了项目。除了在最高检的项目应用以外，盘古NLP大模型还在反电炸等场景上得到应用。NLP大模型的迁移性强，对人工的依赖程度小，少量样本、简单调参即可。2.2.3科学计算大模型所谓科学计算就是把AI的能力辐射到其他领域。在科学计算领域，比如气象、医药、航天航空、海洋、工业、地质等不同场景，在这些场景当中所面临的共同问题就是解偏微分方程。在偏微分方程解的过程当中，盘古大模型可以发挥出它自己得天独厚的优势。比如说神经网络体量很大，所以在解方程的时候，科学计算大模型可以捕捉到小模型无法捕捉到的特征，从而得到更精确的解答。相比于传统方法，用数值模拟的方法求解偏微分方程，求解效率会比较高。在一些极端的场景下，求解效率能够从2天缩短到0.1秒，提升4~5个数量级的程度。在这种情况下，就可以用实时预测能力为科学计算应用提供实时预警，比如在海量预测问题上，可使用实时预警能力提供实时预警，从而提升在各个方面应对突发海事情况的能力。接下来位大家展示盘古科学计算大模型的演示demo。该demo主要是进行全球海浪的实时预测，模拟一个地球的形状，包含全球的陆地和海洋数据。通过模拟给定风速后，全球海洋的海浪高度是可以实时地显示在屏幕上，这也是得益于推理速度的加快。因为盘古大模型使用0.1秒就完成预测，因此可以实时把结果显示出来。同时还可以模拟海洋上的突发情况，比如海洋上可能出现的风暴和台风。在demo当中给大家展示实时生成台风的路径，并且调整这台风的强度、风速、生命周期等参数，就能发现台风对海浪的高度等造成的影响。因此就可以去模拟台风对海洋的海浪造成的影响。所以该模型就可以有效的帮助我们去指导海洋上的生产生活，比如指导渔船去避险，发挥它自己所特有的价值。对于大部分海上作业来说，精确的海浪预报具有重要的价值。与基于超级计算机的传统预报模式相比，Al全球海浪预报模型可以以较低的计算成本，灵活的结合短期气象预报更新结果，快速提供相关海域未来数小时的海况。该预报系统可以为航运公司提供服务，通过海浪数据结合航速航向来优化航行路径，减少航行过程中的碳排放，同时避免遭遇极端海况造成人员和财产损失。2.2.4多模态大模型多模态，是指把图像和文本两种不同的模态结合在一起，它们之间可以进行交互，从而可以帮助我们完成各种各样的应用。比如像趋势预测、辅助设计等，这些在时装行业比较重要的应用。都是得益于多模态大模型，把人类所希望做的事情以文本形式表示出来，然后把它体现成图像的形式，让设计师能够以图像生成设计图的方法，交付到生产线，加速最后的生产过程。在这个过程当中，利用大模型这样的思路，使得图像和文本之间能够高效地进行交互，从而最后完成这样的过程。2.2.5Graph大模型盘古Graph大模型，主要是用来处理结构化数据。以企业报表数据为例，华为与广发证券合作中发现，有些广发证券客户会存在这个财务造假的情况。广发证券通过使用盘古大模型，利用数据可以帮助他们高效分析出哪些企业可能存在造假的情况，从而帮助广发证券更好的去完成业务情况。2019年有496家企业被监管处罚、问询或被ST处理和利用。得益于大模型当中所具备的特征抽取及预测的能力，盘古多模态大模型能构建定制化、高效的产业链条，并在企业的生产、生活当中是可以发挥出更加重大的作用。如果大家对盘古大模型感兴趣，包括对前面所展示的这个demo比较感兴趣的话，请与华为商务部门联系。3.ModelBox加速跨平台高性能AI应用开发和落地随着新基建的推进，以及5G通信、云计算、大数据和物联网的快速发展，人工智能应用的场景越来越多，AI正从极具想象力的概念成为具有超大发展前景的商业赛道，并逐渐渗透到各行各业，催生了技术产业新的发展。在深耕行业AI落地的过程中，我们发现AI的大规模应用落地并非一帆风顺，面临着比传统软件更复杂的难题：部署场景、复杂系统架构涉及端边云多种组合。易购计算平台多样，给应用性能优化带来了更高的技能要求。AI基础推理框架的API不统一，带来繁琐的适配工作。为解决这些难题，在今年的这次大会上，我们对AI开发生产线ModelArts进行了重磅升级，发布了ModelBox端边云统一AI应用开发框架。ModelBox是让模型以统一的格式和接口更高效地运行。通过ModelBox开发者无需过多关注底层技术也能开发出跨平台高性能的AI应用，提升开发效率。开发者在华为云AI开发生产线ModelArtes上完成模型的训练和优化之后，均可以将模型通过ModelBox完成应用的开发和集成，并一键部署到端边云场景的不同设备中运行，打通行业AI应用落地最后一公里。为了帮助开发者快速完成AI应用的开发和部署，ModelBox集成了三大核心技术：高性能并发调度引擎。可实现数据计算和资源管理的精细化智能调度，集成了特别优化过的硬件加速单元。译制的应用编排异构计算组件。丰富的组件覆盖了主流芯片、多数操作系统和主流的推理框架，可屏蔽这三个层次的平台差异。框架中提供了端边云AI系统单元，让开发者快速写出格式一致的AI应用，并结合场景需求，一键部署到端边云不同的设备上运行。基于高性能并发调度引擎，开发者无需掌握底层调度机制，也能保证高性能应用优化效果。ModelBox中将所有的任务都以功能单元的形式封装，一个完整的应用就是由多个功能单元构成。华为云自研一套灵活调度策略，在执行过程中，功能单元的计算将统一由线程池并发调度，确保计算单元被分配到对应的一个硬件中执行。同时计算中数据和执行单元绑定，保证数据处理的合理分配和高吞吐量。根据引擎在实际应用案例中，让典型的图片检测场景的数据吞吐量从54QPS提升到了442QPS，处理时延从0.5亿毫秒降到了0.2毫秒。为了带给开发者更好的开发体验，提供了图编排的开发模式，所有API以功能单元的方式提供，应用开发可以做到像搭积木一样方便。同时针对常用的AI推理场景提供了丰富的译制功能单元，做到低代码/零代码就能完成应用开发。一次开发无需改动代码就能实现端边云不同设备的一致部署运行。三大核心技术带来的收益也是明显的，在节约80%左右的开发成本的情况下，还带来2-10倍的推理性能提升。3.1应用编排异构计算组件，缩短跨平台开发和部署成本ModelBox作为AI应用开发框架，华为云始终关注开发者体验。依据ModelBox的技术内核，华为云提供了完整的开发工具链，可以让开发者能够以自己喜欢的IDE上手ModelBox。ModelBox的丰富工程模板可降低开发门槛，对应用的AI开发部分包含功能单元开发和图编排，可以实现对Python、C++等多种语言的灵活支持和可视化编排的低门槛开发模式。同时还提供完整的调试机制以应对开发中的问题。开发完成以后，ModelBox以RPN或者容器镜像的打包方式，一键发布应用。并且，ModelBox格式的应用支持多种部署方式，可以一键发布成ModelArts云上在线推理服务，也可以通过HiLens端云协同服务，远程部署到端边侧运行。为了实际场景需要，ModelBox还提供灵活的插件，帮助开发者实现模型的权限管理和配置等。3.2ModelBox助力智慧出行应用实现高性能提升和快速落地从去年开始，已经陆续有伙伴开始将AI应用牵引到ModelBox框架上来。以智慧出行场景为例，我们与伙伴全面重构了安全出行方案中的AI推理业务。在重构前，其中的疲劳和分神驾驶检测任务是根据传统的方式，进行AI应用开发和部署。由于业务量的增加，AI运算的性能已经满足不了要求，并且基础平台将带来扩容成本的增加。同时，切换品牌代码需要重新开发，难度就随之增加。在双方团队配合中选择了ModelBox重构现有业务，数据吞吐量提升了2-10倍。以抽烟识别为例，从15QPS提升到了150QPS，在不扩容的情况下，业务能力大幅提高，节约了非常高的硬件成本。由于性能提升，我们也可以大胆尝试更强大的算法，使得识别准确率也有超过10%的提升，同时耗时降低78%。3.3华为云助力ModelBox开发者实现商业成功华为云开源ModelBox，是希望通过开源能够与广大伙伴共同构建端边云协同的AI应用生态。2021年，华为云依托旗帜社区平台完成了源码发布，这也是社区中第一个应用框架类项目。经过半年的开源社区化开发，我们的项目更加完善和强大。今年晚些时候，我们将在下一个版本推出更多的用户体验，优化工具。未来，我们计划提供越来越多的ModelBox开源解决方案，让大家可以结合更多的参考样例和项目做到开箱即用。华为云诚挚邀请广大开发者朋友参与到ModelBox的开源项目中来。希望北向的AI算法应用开发者可以贡献自己的能力，来丰富ModelBox的功能单元和应用场景，同时让自己的应用可以被更多硬件高效运行。也希望南向设备厂商把自己的硬件通过开源项目对接到ModelBox项目中来，这样具有丰富的AI应用，可以补充和扩展硬件的AI使用场景。为降低开发者上手门槛，华为云与国办合作推出了ModelBox生态入门级开发板。开发者可以从开发板套件开始体验ModelBox结合硬件和端游协同带来的便利，将自己的IDEA快速变成现实。同时还为开发者准备了丰富的上手课程，包含入门、进阶和高阶课。通过系列课程掌握ModelBox的基础开发概念，上手体验功能单元和图形化编排的开发模式。正是由于ModelBox天生对平台操作系统和推理框架的适配开放能力，结合统一的应用打包格式，让应用不管是云上还是端边侧，可复制性都大大提高，这就给开发者的商业变现提供了更多可能。为了更好的帮助开发者实现商业成功，华为云AI开发生产线ModelArts和华为云应用商店，帮助开发者打通从开发到落地的变现通路。ModelBox开发的AI应用，可以通过云上平台和销售网络以及集成商伙伴，触达更多的行业客户，带来更多的商业机会。最后华为云AI开发生产线已通过中国信通院评测，是中国信通院认证的首批全能力域领先级AI开发平台。通过不断创新，在国内率先支持MLOps，让更多企业上好云、用好云，进而推动AI进入更多核心生产环节，产生更高价值。