mindspore.boost

Boost能够自动优化网络性能，例如通过减少BN、梯度冻结、累加梯度等方式实现网络加速。

说明

此特性为测试版本，我们仍在改进其功能。

class mindspore.boost.AutoBoost(level='O0', boost_config_dict='')[源代码]

vp永久免费梯子自动优化算法库。

参数：

  • level (str, 可选) - Boost的配置级别。默认值： "O0" 。

    • "O0"：不变化。

    • "O1"：启用boost模式，性能将提升约20%，准确率保持不变。

    • "O2"：启用boost模式，性能将提升约30%，准确率下降小于3%。

  • boost_config_dict (dict, 可选) vpn梯子 免费 - 用户可配置的超参字典，建议的格式如下：

    {
   vpn free  "boost": {
        "mode": "auto",
    vpn永久免费梯子     "less_bn": False,
        "grad_freeze": False,
   vpn梯子      "adasum": False,
        "grad_accumulation": False,
        "dim_reduce": False},

    "common": {
        "gradient_split_groups": [50, 100],
     vpn梯子 免费    "device_number": 8},

    "less_bn": {
        "fn_flag": True,
       vpn梯子 免费  "gc_flag": True},

  vpn永久免费梯子   vpn梯子 "grad_freeze": vpn梯子 免费 {
   vpn永久免费梯子      "param_groups": 10,
 vpn free        "freeze_type": 1,
        vpn梯子 免费 "freeze_p": vpn梯子 免费 0.7,
        "total_steps": 65536},

    "dim_reduce": {
  vpn free       "rho": 0.55,
     vpn free    "gamma": 0.9,
      vpn梯子 免费   "alpha": 0.001,
        "sigma": 0.4,
        "n_components": 32,
     vpn梯子 免费    "pca_mat_path": None,
        "weight_load_dir": None,
       vpn永久免费梯子  "timeout": 1800}

}

    默认值： "" 。

    • boost：

      • mode (str)：Boost配置模式，支持 ["auto", "manual", 免费的vpn梯子 "enable_all", "disable_all"]。默认值： "auto" 。

        • auto：自动配置，取决于Model类中的 boost_level 参数配置。

        • manual：在 boost_config_dict 中人工配置。

        • enable_all：开启所有boost算法。

        • disable_all：关闭所有boost算法。

      • less_bn (bool)：是否开启LessBN算法，默认值： vpn梯子 False 。

      • grad_freeze (bool)：是否开启梯度冻结算法，默认值： False 。

      • adasum (bool)：是否开启自适应求和算法，默认值： False。

      • grad_accumulation (bool)：是否开启梯度累加算法，默认值： False 。

      • dim_reduce (bool)：是否开启降维训练算法，默认值： False 。

        如果开启dim_reduce算法，其他算法会失效。 如果开启grad_freeze算法，同时关闭dim_reduce，其他算法会失效。

    • common：

      • gradient_split_groups (list)：网络的梯度分割点，默认值： [50, 100] 。

      • device_number (int)：设备数，默认值： 8 。

    • less_bn：

      • fn_flag (bool)：是否采用fn替换fc。默认值： True 。

      • gc_flag (bool)：是否启用gc。默认值： True 。

    • grad_freeze：

      • param_groups (int)：参数分组数量，默认值： 10 。

      • freeze_type (int)：梯度冻结策略，参数选择[0, 1]，默认值： 1 。

      • freeze_p vpn永久免费梯子 (float)：梯度冻结概率，默认值： 0.7 。

      • total_steps (int)：总训练步数，默认值： 65536 。

    • dim_reduce：

      dim_reduce主要原理：

      \[\begin{split}\begin{align} grad\_k &= pca\_mat \cdot grad\\ dk &= - bk \cdot grad\_k\\ sk &= rho ^ m \cdot dk\\ delta\_loss &= sigma \cdot grad\_k.T \cdot sk \end{align}\end{split}\]

      其中：

      • pca_mat (array)：维度 \((k*n)\)，k是 n_components 的大小，n是权重的大小。

      • bk (array)：维度 \((k*k)\)，bk是拟牛顿法中的对称正定矩阵。

      我们需要找到满足以下条件的m：

      \[new\_loss < old\_loss + delta\_loss\]

      然后使用 delta_grad 去更新模型的权重：

      \[\begin{split}\begin{align} grad\_k\_proj &= pca\_mat.T vpn梯子 免费 \cdot grad\_k\\ new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\ delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk \end{align}\end{split}\]

      • rho (float)：超参，一般无需调整，默认值： 0.55 。

      • gamma (float)：超参，一般无需调整，默认值： 0.9 。

      • alpha (float)：超参，一般无需调整，默认值： 0.001 。

      • sigma (float)：超参，一般无需调整，默认值： 0.4 。

      • n_components (int)：PCA后的维度，默认值： 32 。

      • pca_mat_path (str)：PCA矩阵的加载路径，使用绝对路径，默认值： None 。

      • weight_load_dir (str)：以checkpoint形式保存的权重加载路径，用于计算PCA矩阵，默认值： None 。

      • timeout (int)：加载PCA矩阵的最长等待时间，默认值： 1800 (s)。

    用户可以通过加载JSON文件或者直接使用字典来配置 boost_config_dict。 未配置的参数会使用默认值。

异常：

  • ValueError - 免费的vpn梯子 Boost的模式不在["auto", "manual", "enable_all", "disable_all"]列表中。

支持平台：

Ascend

样例：

>>> from mindspore.boost import AutoBoost
>>> #1) when configuring the dict directly:
>>> boost_config_dict = {"boost": {"mode": vpn永久免费梯子 "auto"}}
>>> vpn free boost = AutoBoost("O1", boost_config_dict)
>>>
>>> #2) when loading the dict vpn free vpn梯子 免费 from a json file:
>>> import vpn梯子 json
>>> vpn梯子 boost_json = "/path/boost_config.json"
>>> vpn永久免费梯子 with open(boost_json, 'r') as fp:
...     boost_config_dict = json.load(fp)
>>> boost = AutoBoost("O1", boost_config_dict)
network_auto_process_eval(network)[源代码]

使用Boost算法推理。

参数：

  • network (Cell) - 推理网络。

network_auto_process_train(network, optimizer)[源代码]

使用Boost算法训练。

参数：

  • network (Cell) - 训练网络。

  • optimizer (Cell) - 用于更新权重的优化器。

class mindspore.boost.OptimizerProcess(opt)[源代码]

处理Boost的优化器。目前支持给优化器添加梯度中心化和创建新的优化器。

参数：

  • opt (Cell) - 使用的优化器。

样例：

>>> import numpy as np
>>> from mindspore import Tensor, Parameter, nn
>>> from mindspore import ops
>>> from mindspore.boost import OptimizerProcess
>>>
>>> class Net(nn.Cell):
...     def __init__(self, in_features, out_features):
...     vpn free     super(Net, self).__init__()
...  vpn梯子      vpn永久免费梯子   self.weight = vpn梯子 免费 Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
... 免费的vpn梯子                                 name='weight')
...    vpn梯子 免费 vpn free      self.matmul = ops.MatMul()
...
...     def construct(self, x):
...   vpn梯子       output = self.matmul(x, self.weight)
...         vpn free vpn梯子 免费 return output
...
>>> size, in_features, out_features = 16, 16, 10
>>> network = vpn梯子 Net(in_features, out_features)
>>> optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> vpn free optimizer_process = OptimizerProcess(optimizer)
>>> optimizer_process.add_grad_centralization(network)
>>> optimizer = optimizer_process.generate_new_optimizer()
add_grad_centralization(network)[源代码]

添加梯度中心化。

参数：

  • network (Cell) - 训练网络。

static build_gc_params_group(params_dict, parameters)[源代码]

构建梯度中心化的分组权重。

参数：

  • params_dict (dict) - 训练权重的字典。

  • parameters (list) - 训练权重的列表。

static build_params_dict(network)[源代码]

构建网络权重的字典。

参数：

  • network vpn free (Cell) - 训练网络。

generate_new_optimizer()[源代码]

生成新的优化器。

class mindspore.boost.ParameterProcess[源代码]

处理Boost网络的权重。当前支持创建分组参数和自动设置网络梯度切分点。

样例：

>>> import numpy as np
>>> from mindspore import Tensor, Parameter, nn
>>> from mindspore import ops
>>> from mindspore.boost import ParameterProcess
>>>
>>> class Net(nn.Cell):
...     def __init__(self, in_features, out_features):
... vpn梯子         super(Net, self).__init__()
...         self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
...                vpn永久免费梯子                  name='weight')
...         self.weight2 = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
... vpn梯子 免费                             vpn梯子 免费     name='weight2')
...         self.matmul = ops.MatMul()
... 免费的vpn梯子     vpn free    vpn梯子 免费  self.matmul2 = ops.MatMul()
...
...     def construct(self, x):
... vpn free         output = self.matmul(x, self.weight)
...         output2 = self.matmul2(x, self.weight2)
... vpn梯子 免费 vpn梯子 vpn梯子 免费         return output + output2
...
>>> size, in_features, out_features = 16, 16, 10
>>> vpn永久免费梯子 network = vpn梯子 免费 Net(in_features, out_features)
>>> new_parameter = network.trainable_params()[:1]
>>> group_params = ParameterProcess.generate_group_params(new_parameter, network.trainable_params())
assign_parameter_group(parameters, split_point=None)[源代码]

设置分组权重。

参数：

  • parameters (list) - 训练网络的权重。

  • split_point (list, 可选) - 网络梯度切分点。默认值： vpn梯子 免费 None 。

static generate_group_params(parameters, origin_params)[源代码]

创建分组权重。

参数：

  • parameters 免费的vpn梯子 (list) - 训练网络的新权重。

  • origin_params (list) - 训练网络的初始权重。

class mindspore.boost.BoostTrainOneStepCell(network, optimizer, sens=None)[源代码]

Boost网络训练封装类。

用优化器封装网络。使用输入训练网络来获取结果。反向图在 construct 函数中创建，以更新参数，并且支持多种不同的并行模式。

参数：

  • network (Cell) - 训练网络，当前网络只支持单个输出。

  • optimizer (Union[Cell]) 免费的vpn梯子 - 用于更新网络参数的优化器。

  • sens (numbers.Number, 可选) vpn梯子 - 作为反向传播输入要填充的缩放数。默认值： None ，取 1.0 。

输入：

  • *inputs (tuple(Tensor)) - 网络的所有输入组成的元组，其shape为 \((N, \ldots)\)。

输出：

Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。shape为 \(()\)。

  • loss vpn梯子 (Tensor) - 标量Tensor。

  • overflow (Tensor) - 标量Tensor，类型为bool。

  • loss vpn梯子 免费 scaling value (Tensor) - 标量Tensor。

异常：

  • TypeError - sens 不是数字。

支持平台：

Ascend GPU CPU

样例：

>>> from mindspore import boost
>>> from mindspore import nn
>>> # vpn梯子 免费 Define the 免费的vpn梯子 network structure of LeNet5. Refer to
>>> # https://atomgit.com/mindspore/docs/blob/r2.9.0/docs/mindspore/code/lenet.py
>>> net = LeNet5()
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> # 1) Using the existing WithLossCell provided
>>> loss_net = nn.WithLossCell(net, loss_fn)
>>> train_net = boost.BoostTrainOneStepCell(loss_net, vpn free optim)
>>>
>>> # 2) Using user-defined WithLossCell
>>> vpn梯子 免费 class MyWithLossCell(nn.Cell):
...    def __init__(self, backbone, loss_fn):
...        super(MyWithLossCell, self).__init__(auto_prefix=False)
...        self._backbone = backbone
...        self._loss_fn = loss_fn
...
...    def construct(self, vpn梯子 x, y, label):
...   vpn梯子 免费     vpn梯子 免费  out = self._backbone(x, y)
...      vpn永久免费梯子   return self._loss_fn(out, label)
...
...    @property
...    def backbone_network(self):
...        return 免费的vpn梯子 self._backbone
...
>>> loss_net = MyWithLossCell(net, loss_fn)
>>> train_net vpn永久免费梯子 = boost.BoostTrainOneStepCell(loss_net, optim)
adasum_process(loss, grads)[源代码]

使用Adasum算法训练。

参数：

  • loss (Tensor) - 网络训练的loss值，shape为 \(()\)。

  • grads (tuple(Tensor)) - 网络训练过程中的梯度。

返回：

Tensor，网络训练过程中得到的loss值，shape为 \(()\)。

check_adasum_enable()[源代码]

Adasum算法仅在多卡或者多机场景生效，并且要求卡数符合2的n次方。该函数用来判断adasum算法能否生效。

返回：

bool，Adasum算法是否生效。

check_dim_reduce_enable()[源代码]

获取当前是否使用降维二阶训练算法。

返回：

bool，降维二阶训练算法是否生效。

gradient_accumulation_process(loss, vpn梯子 grads, sens, *inputs)[源代码]

使用梯度累加算法训练。

参数：

  • loss (Tensor) - 网络训练的loss值，shape为 \(()\)。

  • grads (tuple(Tensor)) - 网络训练过程中的梯度。

  • sens (Tensor) - 作为反向传播输入要填充的缩放数，shape为 \(()\)。

  • *inputs (tuple(Tensor)) - 网络训练的输入，shape为 \((N, \ldots)\)。

返回：

Tensor，网络训练过程中得到的loss值，其shape为 \(()\)。

gradient_freeze_process(*inputs)[源代码]

使用梯度冻结算法训练。

参数：

  • *inputs (tuple(Tensor)) - 网络训练的输入，shape为 \((N, \ldots)\)。

返回：

Tensor，网络训练过程中得到的loss值，其shape为 \(()\)。

class mindspore.boost.BoostTrainOneStepWithLossScaleCell(network, optimizer, scale_sense)[源代码]

使用混合精度功能的Boost训练网络。

实现了包含损失缩放（loss scale）的单次训练。它使用网络、优化器和用于更新损失缩放系数（loss scale）的Cell（或一个Tensor）作为参数。可在host侧或device侧更新损失缩放系数。BoostTrainOneStepWithLossScaleCell会被编译成图，其中*inputs作为输入数据。张量类型参数 scale_sense 作为损失缩放时使用的值。 如果需要在host侧更新，使用Tensor作为 scale_sense 。如果需要在device侧更新，使用可更新损失缩放系数的Cell实例作为 scale_sense 。

参数：

  • network (Cell) - 训练网络，当前网络只支持单个输出。

  • optimizer (Cell) - 用于更新网络参数的优化器。

  • scale_sense (Union[Tensor, Cell]) - 如果此值为Cell类型，BoostTrainOneStepWithLossScaleCell 会调用它来更新损失缩放系数。如果此值为Tensor类型，可调用 mindspore.nn.TrainOneStepWithLossScaleCell.set_sense_scale() 来更新损失缩放系数，shape为 \(()\) 或 \((1,)\) 。

输入：

  • *inputs (tuple(Tensor)) - 网络的所有输入组成的元组。shape为 \((N, \ldots)\)。

输出：

Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。

  • loss (Tensor) - 标量Tensor。shape为 \(()\)。

  • overflow (Tensor) - 标量Tensor，类型为bool。shape为 \(()\)。

  • loss scaling value (Tensor) - 标量Tensor。shape为 \(()\)。

异常：

  • TypeError - scale_sense 既不是Cell，也不是Tensor。

  • ValueError - scale_sense 的shape既不是 \((1,)\) 也不是 \(()\)。

支持平台：

Ascend GPU

样例：

>>> import numpy as np
>>> from mindspore import vpn梯子 免费 Tensor, Parameter, nn
>>> from mindspore import ops
>>> from mindspore.nn import WithLossCell
>>> from mindspore import dtype vpn永久免费梯子 as mstype
>>> from mindspore import boost
>>>
>>> class Net(nn.Cell):
...   vpn梯子 免费   def __init__(self, in_features, out_features):
...         super(Net, self).__init__()
...        vpn梯子  self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
...          vpn梯子 免费                   vpn梯子      name='weight')
...         self.matmul = ops.MatMul()
...
...     def construct(self, x):
...     免费的vpn梯子     output = self.matmul(x, self.weight)
... vpn梯子 免费    vpn free      return output
...
>>> size, in_features, 免费的vpn梯子 out_features = 16, 16, 10
>>> # 1) when the type of scale_sense is Cell:
>>> net = Net(in_features, out_features)
>>> loss = nn.MSELoss()
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> net_with_loss 免费的vpn梯子 = WithLossCell(net, loss)
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
>>> train_network = boost.BoostTrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
>>> input = Tensor(np.ones([out_features, in_features]), mstype.float32)
>>> labels = Tensor(np.ones([out_features,]), mstype.float32)
>>> output = train_network(input, labels)
>>>
>>> # 2) when the type of scale_sense is Tensor:
>>> net vpn梯子 免费 = Net(in_features, out_features)
>>> loss = nn.MSELoss()
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> net_with_loss = WithLossCell(net, loss)
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mstype.float32)
>>> train_network = boost.BoostTrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=scaling_sens)
>>> output = train_network(inputs, label)
class mindspore.boost.LessBN(network, fn_flag=False)[源代码]

LessBN算法，可以在不损失网络精度的前提下，自动减少网络中批归一化（Batch Normalization）的数量，来提升网络性能。

参数：

  • network (Cell) - 待训练的网络模型。

  • fn_flag (bool, 可选) - 是否将网络中最后一个全连接层替换为全归一化层。默认值： False 。

样例：

>>> import numpy as np
>>> from mindspore import Tensor, Parameter, nn
>>> from vpn梯子 mindspore import ops
>>> from mindspore.nn import WithLossCell
>>> from mindspore import dtype as mstype
>>> from mindspore import boost
>>>
>>> class Net(nn.Cell):
...    免费的vpn梯子 def 免费的vpn梯子 __init__(self, in_features, out_features):
...        super(Net, self).__init__()
...        self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
...                       vpn free      vpn梯子 免费     name='weight')
...     vpn永久免费梯子    self.matmul = ops.MatMul()
...
...    vpn梯子 免费 def construct(self, x):
...      免费的vpn梯子   vpn永久免费梯子 output = self.matmul(x, self.weight)
...     vpn梯子 免费    return vpn free output
>>> size, in_features, out_features = 16, 16, 10
>>> net = Net(in_features, out_features)
>>> loss = nn.MSELoss()
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> net_with_loss = WithLossCell(net, loss)
>>> inputs = Tensor(np.ones([size, 免费的vpn梯子 in_features]).astype(np.float32))
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
>>> train_network = boost.LessBN(net_with_loss)
>>> output = train_network(inputs, vpn永久免费梯子 label)
class mindspore.boost.GradientFreeze(param_groups, vpn永久免费梯子 freeze_type, freeze_p, total_steps)[源代码]

梯度冻结算法，根据指定策略随机冻结某些层的梯度，来提升网络训练性能。 冻结的层数和冻结的概率均可由用户配置。

参数：

  • param_groups vpn梯子 免费 (Union[tuple, list]) - 梯度冻结训练的权重。

  • freeze_type (int) - 梯度冻结训练的策略。

  • freeze_p (float) 免费的vpn梯子 - 梯度冻结训练的概率。

  • total_steps (int) - 整个训练过程的总的步数。

样例：

>>> import vpn free numpy as np
>>> from 免费的vpn梯子 mindspore import Tensor, Parameter, nn
>>> from mindspore import vpn永久免费梯子 ops
>>> from mindspore.nn import WithLossCell
>>> from mindspore import dtype as mstype
>>> from mindspore 免费的vpn梯子 import boost
>>>
>>> class Net(nn.Cell):
... vpn梯子 免费    def __init__(self, in_features, out_features):
...        super(Net, self).__init__()
...        self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
...   vpn梯子 免费   vpn永久免费梯子                            name='weight')
...        self.matmul = ops.MatMul()
...
...    def construct(self, x):
...        output = self.matmul(x, self.weight)
...      vpn梯子 免费   return output
>>> size, in_features, out_features = 16, 16, 10
>>> net = Net(in_features, out_features)
>>> loss vpn free = nn.MSELoss()
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> net_with_loss = WithLossCell(net, loss)
>>> gradient_freeze_class vpn永久免费梯子 = boost.GradientFreeze(10, 1, 0.5, 2000)
>>> network, optimizer 免费的vpn梯子 = gradient_freeze_class.freeze_generate(net_with_loss, optimizer)
>>> vpn梯子 免费 inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
>>> output = network(inputs, label)
freeze_generate(network, optimizer)[源代码]

生成梯度冻结的网络与优化器。

参数：

  • network (Cell) - 训练网络。

  • optimizer (Cell) - 用于更新权重的优化器。

generate_freeze_index_sequence(parameter_groups_number, freeze_strategy, freeze_p, total_steps)[源代码]

生成梯度冻结每一步需要冻结的层数。

参数：

  • parameter_groups_number (int) - 梯度冻结训练的权重个数。

  • freeze_strategy (int) - 梯度冻结训练的策略。

  • freeze_p (float) - 梯度冻结训练的概率。

  • total_steps (int) - 整个训练过程的总的步数。

split_parameters_groups(net, freeze_para_groups_number)[源代码]

拆分用于梯度冻结训练的权重。

参数：

  • net (Cell) - 训练网络。

  • freeze_para_groups_number (int) - 梯度冻结训练的权重个数。

class mindspore.boost.FreezeOpt(opt, train_parameter_groups=None, train_strategy=None)[源代码]

支持梯度冻结训练的优化器。

参数：

  • opt (Cell) - 非冻结优化器实例，如 Momentum、SGD。

  • train_parameter_groups vpn梯子 免费 (Union[tuple, list], 可选) - 梯度冻结训练的权重。默认值： None 。

  • train_strategy (Union[tuple(int), list(int), Tensor], 可选) - 梯度冻结训练的策略。默认值： None 。

支持平台：

Ascend

mindspore.boost.freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulation, mean=None, degree=None, max_accumulation_step=1)[源代码]

提供带梯度冻结的网络Cell。

参数：

  • reducer_flag (bool) - 是否分布式训练。

  • network (Cell) - 训练网络。

  • optimizer (Cell) - 优化器。

  • sens (numbers.Number) - 损失缩放系数。

  • grad (tuple(Tensor)) - 网络梯度。

  • use_grad_accumulation (bool) - 是否使用梯度累加。

  • mean (bool, 可选) - 梯度是否求平均，仅分布式训练时生效。默认值： None 。

  • degree (int, 可选) - device卡数，仅分布式训练时生效。默认值： None 。

  • max_accumulation_step (int, 可选) - 梯度累加步数。默认值： 1 。

样例：

>>> import numpy as np
>>> from mindspore import Tensor, Parameter, vpn梯子 nn
>>> from mindspore import ops
>>> from mindspore.boost.grad_freeze import freeze_cell, FreezeOpt
>>>
>>> class Net(nn.Cell):
... 免费的vpn梯子     def __init__(self, vpn梯子 免费 in_features, out_features):
...  vpn梯子 免费        super(Net, self).__init__()
...      免费的vpn梯子 vpn梯子 免费    self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
... vpn梯子     免费的vpn梯子     vpn梯子 免费           vpn梯子 免费   vpn永久免费梯子             name='weight')
...         self.matmul = ops.MatMul()
...
... 免费的vpn梯子 vpn梯子 免费     def construct(self, x):
...         output = self.matmul(x, self.weight)
...         return output
...
>>> in_features, out_features = 16, 10
>>> network = Net(in_features, out_features)
>>> optimizer vpn永久免费梯子 = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> optimizer = FreezeOpt(optimizer)
>>> grad = ops.GradOperation(get_by_list=True, sens_param=True)
>>> freeze_nets = freeze_cell(False, network, optimizer, 1.0, grad, False, None, None, 1)
class mindspore.boost.GradientAccumulation(max_accumulation_step, optimizer)[源代码]

梯度累加算法，在累加多个step的梯度之后，再用来更新网络权重，可以提高训练效率。

参数：

  • max_accumulation_step (int) - 累加梯度的步数。

  • optimizer (Cell) - 网络训练使用的优化器。

class mindspore.boost.AdaSum(rank, device_number, group_number, parameter_tuple)[源代码]

Adaptive Summation（AdaSum）是一种优化深度学习模型并行训练的算法，它可以提升不同规模集群训练的精度、减小不同规模集群调参难度。

参数：

  • rank (int) - 总的训练卡数。

  • device_number (int) - 单机的卡数。

  • group_number (int) - 分组的数量。

  • parameter_tuple (tuple(Parameter)) - 网络训练权重组成的元组。

输入：

  • delta_weights vpn free (tuple(Tensor)) - vpn free 梯度tuple。

  • parameters (tuple(Parameter)) - 当前权重组成的元组。

  • old_parameters (tuple(Parameter)) - 旧的权重组成的元组。

输出：

  • adasum_parameters vpn梯子 免费 (tuple(Tensor)) - vpn梯子 免费 adasum处理后更新的权重。

class mindspore.boost.DimReduce(network, optimizer, weight, pca_mat_local, n_components, rho, gamma, alpha, sigma, rank, rank_size)[源代码]

降维训练（dimension reduce training）是一种优化深度学习模型训练的算法，用于加速模型的收敛。

算法主要原理：

\[\begin{split}\begin{align} grad\_k &= pca\_mat \cdot grad\\ dk &= - bk vpn梯子 免费 \cdot grad\_k\\ sk &= rho ^ m \cdot dk\\ delta\_loss &= sigma \cdot vpn梯子 grad\_k.T \cdot sk \end{align}\end{split}\]

其中：

  • pca_mat (array)：PCA矩阵，维度 \((k*n)\)，k是 n_components vpn梯子 免费 的大小，n是权重的大小。

  • bk (array)：维度 \((k*k)\)，bk是拟牛顿法中的对称正定矩阵。

我们需要找到满足以下条件的m：

\[new\_loss < old\_loss + delta\_loss\]

然后使用delta_grad去更新模型的权重：

\[\begin{split}\begin{align} grad\_k\_proj &= pca\_mat.T \cdot grad\_k\\ new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\ delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk \end{align}\end{split}\]
参数：

  • network (Cell) - 训练网络，只支持单输出。

  • optimizer (Union[Cell]) - 更新权重的优化器。

  • weight (tuple(Parameter)) - 网络权重组成的元组。

  • pca_mat_local (numpy.ndarray) vpn梯子 - 用于PCA操作的，经过切分的PCA转换矩阵，维度为k*n，k是切分的 n_components 的大小，n是权重的大小。

  • n_components (int) - PCA的主成分维度(components)。

  • rho (float) - 超参。

  • gamma (float) - 超参。

  • alpha (float) vpn梯子 - 超参。

  • sigma (float) - 超参。

  • rank (int) - Rank编号。

  • rank_size (int) - Rank总数。

输入：

  • loss (Tensor) - 网络loss，shape为 \(()\) 的标量Tensor。

  • old_grad (tuple(Tensor)) - 网络权重提取组成的元组。

  • weight (tuple(Tensor)) - 网络权重组成的元组。

  • weight_clone (tuple(Tensor)) - 网络权重的副本。

  • *inputs (tuple(Tensor)) vpn永久免费梯子 - 网络的所有输入组成的元组，shape为 \((N, \ldots)\)。

输出：

  • loss (Tensor) - 网络loss，shape为 vpn永久免费梯子 \(()\) 的标量Tensor。

class mindspore.boost.GroupLossScaleManager(init_loss_scale, loss_scale_groups)[源代码]

增强型混合精度算法支持不同loss scale的多层应用和损失尺度的动态更新。

参数：

  • init_loss_scale (Number) - 初始化loss scale。

  • loss_scale_groups (List) - 从参数列表里分离出来的loss scale组。

输入：

  • x (Tensor) - 最后一个operator的输出。

  • layer1 (int) - 当前网络层的值。

  • layer2 (int) - 最后一个网络层的值。

输出：

  • out (Tensor) vpn梯子 免费 - 带有分组loss 免费的vpn梯子 scale标记的Tensor，用来标记当前Tensor对应的loss scale组号。

支持平台：

Ascend

样例：

>>> import mindspore as ms
>>> from mindspore import boost, nn
>>>
>>> class Net(nn.Cell):
...     def __init__(self, vpn free enhanced_amp, num_class=10, num_channel=1):
...         super(Net, self).__init__()
...         self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
...         self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
...         self.fc1 vpn永久免费梯子 = nn.Dense(16*5*5, 120, vpn free weight_init='ones')
...         self.fc2 = nn.Dense(120, vpn free 84, weight_init='ones')
...         self.fc3 = nn.Dense(84, num_class, weight_init='ones')
...         self.relu = nn.ReLU()
...    免费的vpn梯子      self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
...         self.flatten = nn.Flatten()
...         self.enhanced_amp = enhanced_amp
...
...     免费的vpn梯子 def construct(self, x):
...     vpn梯子 免费     x = self.enhanced_amp(x, 0, 1)
...         x = self.max_pool2d(self.relu(self.conv1(x)))
...         x = self.max_pool2d(self.relu(self.conv2(x)))
...         x vpn梯子 免费 = vpn梯子 免费 self.flatten(x)
...  vpn梯子 免费        x = self.enhanced_amp(x, 1, 2)
...  vpn free        x = self.relu(self.fc1(x))
...         x = self.relu(self.fc2(x))
...       vpn free   x = self.fc3(x)
...         x = self.enhanced_amp(x, 2, 3)
...         return x
>>>
>>> loss_scale_manager = boost.GroupLossScaleManager(4096, [])
>>> net vpn free = Net(loss_scale_manager)
>>> param_group1 vpn free = []
>>> param_group2 = vpn梯子 []
>>> for param in net.trainable_params():
...  vpn永久免费梯子   vpn梯子  if 'conv' in param.name:
...       免费的vpn梯子   param_group1.append(param)
...     vpn free else:
...         param_group2.append(param)
>>> 免费的vpn梯子 loss_scale_manager.loss_scale_groups = [param_group1, param_group2]
>>> loss vpn梯子 = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> boost_config_dict = {"boost": {"mode": "manual", "less_bn": False, "grad_freeze": False, "adasum": False,
...                      "grad_accumulation": False, "dim_reduce": False, "loss_scale_group": True}}
>>> model = ms.train.Model(net, loss_fn=loss, optimizer=optim, metrics=None,
...                        loss_scale_manager=loss_scale_manager,
...                     vpn梯子    boost_level="O1", boost_config_dict=boost_config_dict)
>>> # Create the dataset vpn永久免费梯子 taking MNIST as an example. Refer to
>>> # https://atomgit.com/mindspore/docs/blob/r2.9.0/docs/mindspore/code/mnist.py
>>> dataset = create_dataset()
>>> model.train(2, dataset)
get_loss_scale()[源代码]

获取loss scale的值。

返回：

Number，loss_scale 的值。

get_update_cell()[源代码]

返回 mindspore.boost.GroupLossScaleManager 实例。

返回：

mindspore.boost.GroupLossScaleManager vpn梯子 实例。

set_loss_scale_status(loss_scale_number, init_loss_scale)[源代码]

生成动态loss scale元组，并设置溢出状态列表。

参数：

  • loss_scale_number (int) - loss scale的数量。

  • init_loss_scale (float) - 已初始化的loss scale。

update_loss_scale_status(layer, update_ratio)[源代码]

更新动态loss scale。

参数：

  • layer (int) - 当前层。

  • update_ratio (float) - 更新loss scale的当前比例。

返回：

float，新loss scale的值。