mindspore.boost
Boost能够自动加速网络,如减少BN/梯度冻结/累加梯度等。
说明
此特性为测试版本,我们仍在改进其功能。
- class mindspore.boost.AutoBoost(level='O0', boost_config_dict='')[源代码]
MindSpore自动优化算法库。
- 参数:
level (str) - Boost的配置级别,默认值:
"O0"
。“O0”:不变化。
“O1”:启用boost模式,性能将提升约20%,准确率保持不变。
“O2”:启用boost模式,性能将提升约30%,准确率下降小于3%。
boost_config_dict (dict) - 用户可配置的超参字典,建议的格式如下:
{ "boost": { "mode": "auto", "less_bn": False, "grad_freeze": False, "adasum": False, "grad_accumulation": False, "dim_reduce": False}, "common": { "gradient_split_groups": [50, 100], "device_number": 8}, "less_bn": { "fn_flag": True, "gc_flag": True}, "grad_freeze": { "param_groups": 10, "freeze_type": 1, "freeze_p": 0.7, "total_steps": 65536}, "dim_reduce": { "rho": 0.55, "gamma": 0.9, "alpha": 0.001, "sigma": 0.4, "n_components": 32, "pca_mat_path": None, "weight_load_dir": None, "timeout": 1800} }
默认值:
""
。boost:
mode (str):Boost配置模式,支持 [“auto”, “manual”, “enable_all”, “disable_all”]。默认值:
"auto"
。auto:自动配置,取决于Model类中的 boost_level 参数配置。
manual:在 boost_config_dict 中人工配置。
enable_all:开启所有boost算法。
disable_all:关闭所有boost算法。
less_bn (bool):是否开启LessBN算法,默认值:
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
,采用fn替换fc。gc_flag (bool):是否启用gc,默认值:
True
,启用gc。
grad_freeze:
param_groups (int):参数分组数量,默认值:
10
。freeze_type (int):梯度冻结策略,参数选择[0, 1],默认值:
1
。freeze_p (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 \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 - Boost的模式不在[“auto”, “manual”, “enable_all”, “disable_all”]这个列表中。
- 支持平台:
Ascend
样例:
>>> from mindspore.boost import AutoBoost >>> #1) when configuring the dict directly: >>> boost_config_dict = {"boost": {"mode": "auto"}} >>> boost = AutoBoost("O1", boost_config_dict) >>> >>> #2) when loading the dict from a json file: >>> import json >>> boost_json = "/path/boost_config.json" >>> with open(boost_json, 'r') as fp: ... boost_config_dict = json.load(fp) >>> boost = AutoBoost("O1", boost_config_dict)
- 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): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.matmul = ops.MatMul() ... ... def construct(self, x): ... output = self.matmul(x, self.weight) ... return output ... >>> size, in_features, out_features = 16, 16, 10 >>> network = Net(in_features, out_features) >>> optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9) >>> optimizer_process = OptimizerProcess(optimizer) >>> optimizer_process.add_grad_centralization(network) >>> optimizer = optimizer_process.generate_new_optimizer()
- class mindspore.boost.ParameterProcess[源代码]
处理Boost网络的权重。当前支持创建分组参数和自动设置网络梯度切分点。
样例:
>>> import numpy as np >>> from mindspore import Tensor, Parameter, nn >>> import mindspore.ops as ops >>> from mindspore.boost import ParameterProcess >>> >>> class Net(nn.Cell): ... def __init__(self, in_features, out_features): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.weight2 = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight2') ... self.matmul = ops.MatMul() ... self.matmul2 = ops.MatMul() ... ... def construct(self, x): ... output = self.matmul(x, self.weight) ... output2 = self.matmul2(x, self.weight2) ... return output + output2 ... >>> size, in_features, out_features = 16, 16, 10 >>> network = Net(in_features, out_features) >>> new_parameter = network.trainable_params()[:1] >>> group_params = ParameterProcess.generate_group_params(new_parameter, network.trainable_params())
- class mindspore.boost.BoostTrainOneStepCell(network, optimizer, sens=None)[源代码]
Boost网络训练封装类。
用优化器封装网络。使用输入训练网络来获取结果。反向图在 construct 函数中创建,以更新参数,并且支持多种不同的并行模式。
- 参数:
network (Cell) - 训练网络,当前网络只支持单个输出。
optimizer (Union[Cell]) - 用于更新网络参数的优化器。
sens (numbers.Number) - 作为反向传播输入要填充的缩放数,默认值:
None
,取1.0
。
- 输入:
*inputs (Tuple(Tensor)) - 网络的所有输入组成的元组,其shape为 \((N, \ldots)\)。
- 输出:
Tuple,包含三个Tensor,分别为损失函数值、溢出状态和当前损失缩放系数。shape为 \(()\)。
loss(Tensor),标量Tensor。
overflow(Tensor),标量Tensor,类型为bool。
loss scaling value(Tensor),标量Tensor。
- 异常:
TypeError - 如果 sens 不是一个数字。
- 支持平台:
Ascend
GPU
CPU
样例:
>>> from mindspore import boost >>> from mindspore import nn >>> # Define the network structure of LeNet5. Refer to >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/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 WithLossCell existing provide >>> loss_net = nn.WithLossCell(net, loss_fn) >>> train_net = boost.BoostTrainOneStepCell(loss_net, optim) >>> >>> #2) Using user-defined WithLossCell >>> 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, x, y, label): ... out = self._backbone(x, y) ... return self._loss_fn(out, label) ... ... @property ... def backbone_network(self): ... return self._backbone ... >>> loss_net = MyWithLossCell(net, loss_fn) >>> train_net = 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算法能否生效。
- 返回:
enable_adasum (bool),Adasum算法是否生效。
- gradient_accumulation_process(loss, grads, sens, *inputs)[源代码]
使用梯度累加算法训练。
- 参数:
loss (Tensor) - 网络训练的loss值。shape为 \(()\)。
grads (tuple(Tensor)) - 网络训练过程中的梯度。
sens (Tensor) - 作为反向传播输入要填充的缩放数。shape为 \(()\)。
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 Tensor, Parameter, nn >>> import mindspore.ops as ops >>> from mindspore.nn import WithLossCell >>> from mindspore import dtype as mstype >>> from mindspore import boost >>> >>> class Net(nn.Cell): ... def __init__(self, in_features, out_features): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.matmul = ops.MatMul() ... ... def construct(self, x): ... output = self.matmul(x, self.weight) ... return output ... >>> size, in_features, 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 = 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 = 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 >>> import mindspore.ops as ops >>> from mindspore.nn import WithLossCell >>> from mindspore import dtype as mstype >>> from mindspore import boost >>> >>> class Net(nn.Cell): ... def __init__(self, in_features, out_features): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.matmul = ops.MatMul() ... ... def construct(self, x): ... output = self.matmul(x, self.weight) ... return 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, 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, label)
- class mindspore.boost.GradientFreeze(param_groups, freeze_type, freeze_p, total_steps)[源代码]
梯度冻结算法,根据指定策略随机冻结某些层的梯度,来提升网络训练性能。 冻结的层数和冻结的概率均可由用户配置。
- 参数:
param_groups (Union[tuple, list]) - 梯度冻结训练的权重。
freeze_type (int) - 梯度冻结训练的策略。
freeze_p (float) - 梯度冻结训练的概率。
total_steps (int) - 整个训练过程的总的步数。
样例:
>>> import numpy as np >>> from mindspore import Tensor, Parameter, nn >>> import mindspore.ops as ops >>> from mindspore.nn import WithLossCell >>> from mindspore import dtype as mstype >>> from mindspore import boost >>> >>> class Net(nn.Cell): ... def __init__(self, in_features, out_features): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.matmul = ops.MatMul() ... ... def construct(self, x): ... output = self.matmul(x, self.weight) ... return 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) >>> gradient_freeze_class = boost.GradientFreeze(10, 1, 0.5, 2000) >>> network, optimizer = gradient_freeze_class.freeze_generate(net_with_loss, optimizer) >>> 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) - 用于更新权重的优化器。
- class mindspore.boost.FreezeOpt(opt, train_parameter_groups=None, train_strategy=None)[源代码]
支持梯度冻结训练的优化器。
- 参数:
opt (Cell) - 非冻结优化器实例,如 Momentum,SGD。
train_parameter_groups (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, nn >>> import mindspore.ops as ops >>> from mindspore.boost.grad_freeze import freeze_cell, FreezeOpt >>> >>> class Net(nn.Cell): ... def __init__(self, in_features, out_features): ... super(Net, self).__init__() ... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), ... name='weight') ... self.matmul = ops.MatMul() ... ... 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 = 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 (Tuple(Tensor)) - 梯度tuple。
parameters (Tuple(Parameter)) - 当前权重组成的元组。
old_parameters (Tuple(Parameter)) - 旧的权重组成的元组。
- 输出:
adasum_parameters (Tuple(Tensor)) - 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 \cdot grad\_k\\ sk &= rho ^ m \cdot dk\\ delta\_loss &= sigma \cdot grad\_k.T \cdot sk \end{align}\end{split}\]其中:
pca_mat (array): PCA矩阵,维度 \((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 \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) - 用于PCA操作的,经过切分的PCA转换矩阵,维度为k*n,k是切分的 n_components 的大小,n是权重的大小。
n_components (int) - PCA的主成分维度(components)。
rho (float) - 超参。
gamma (float) - 超参。
alpha (float) - 超参。
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)) - 网络的所有输入组成的元组,shape为 \((N, \ldots)\)。
- 输出:
loss (Tensor) - 网络loss,shape为 \(()\) 的标量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) - 带有分组loss scale标记的Tensor,用来标记当前Tensor对应的loss scale组号。
- 支持平台:
Ascend
样例:
>>> import mindspore as ms >>> from mindspore import boost, nn >>> >>> class Net(nn.Cell): ... def __init__(self, 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 = nn.Dense(16*5*5, 120, weight_init='ones') ... self.fc2 = nn.Dense(120, 84, weight_init='ones') ... self.fc3 = nn.Dense(84, num_class, weight_init='ones') ... self.relu = nn.ReLU() ... self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) ... self.flatten = nn.Flatten() ... self.enhanced_amp = enhanced_amp ... ... def construct(self, x): ... 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 = self.flatten(x) ... x = self.enhanced_amp(x, 1, 2) ... x = self.relu(self.fc1(x)) ... x = self.relu(self.fc2(x)) ... x = self.fc3(x) ... x = self.enhanced_amp(x, 2, 3) ... return x >>> >>> loss_scale_manager = boost.GroupLossScaleManager(4096, []) >>> net = Net(loss_scale_manager) >>> param_group1 = [] >>> param_group2 = [] >>> for param in net.trainable_params(): ... if 'conv' in param.name: ... param_group1.append(param) ... else: ... param_group2.append(param) >>> loss_scale_manager.loss_scale_groups = [param_group1, param_group2] >>> loss = 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, ... boost_level="O1", boost_config_dict=boost_config_dict) >>> # Create the dataset taking MNIST as an example. Refer to >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/mnist.py >>> dataset = create_dataset() >>> model.train(2, dataset)