MindSpore静态LossScale和动态LossScale的区别

背景信息

在混合精度中，使用float16类型来替代float32类型存储数据，从而达到减少内存和提高计算速度的效果。但是由于float16类型要比float32类型表示的范围小很多，所以当某些参数（比如说梯度）在训练过程中变得很小时，就会发生数据下溢的情况，进而影响网络精度。而loss scale正是为了解决float16类型数据下溢问题的，LossScale的主要思想是在计算loss时，将loss扩大一定的倍数，由于链式法则的存在，梯度也会相应扩大，然后在优化器更新权重时再缩小相应的倍数，从而避免了数据下溢的情况又不影响计算结果；而LossScale又可分为静态LossScale与动态LossScale。

MindSpore中提供了两种Loss Scale的方式，分别是FixedLossScaleManager和DynamicLossScaleManager，需要和Model配合使用。在使用Model构建模型时，可配置混合精度策略amp_level和Loss Scale方式loss_scale_manager。

1、静态LossScale

LossScale在训练过程中使用固定scale的值，且在训练过程中不会改变scale的值，scale的值由入参loss_scale控制，可以由用户指定，不指定则取默认值。

静态LossScale算子的另一个参数是drop_overflow_update，用来控制发生溢出时是否更新参数。

一般情况下LossScale功能不需要和优化器配合使用，但如果drop_overflow_update为False，那么优化器需设置loss_scale的值，且loss_scale的值要与静态LossScale算子相同。

FixedLossScaleManager具体用法如下：

1.import必要的库，并声明使用图模式下执行。

import numpy as npimport mindspore as msimport mindspore.nn as nnfrom mindspore.nn import Accuracyfrom mindspore.common.initializer import Normalfrom mindspore import dataset as ds
#ms.set_seed(0)ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")

2.定义LeNet5网络模型，任何网络模型都可以使用Loss Scale机制。

class LeNet5(nn.Cell):
    """        Lenet network
        Args:            num_class (int): Number of classes. Default: 10.            num_channel (int): Number of channels. Default: 1.
        Returns:            Tensor, output tensor    """
    def __init__(self, num_class=10, num_channel=1):
        super(LeNet5, 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=Normal(0.02))
        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
        self.relu = nn.ReLU()
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
        self.flatten = nn.Flatten()

    def construct(self, x):
        x = self.max_pool2d(self.relu(self.conv1(x)))
        x = self.max_pool2d(self.relu(self.conv2(x)))
        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

3.定义数据集和训练流程中常用的接口。

# create datasetdef get_data(num, img_size=(1, 32, 32), num_classes=10, is_onehot=True):
    for _ in range(num):
        img = np.random.randn(*img_size)
        target = np.random.randint(0, num_classes)
        target_ret = np.array([target]).astype(np.float32)
        if is_onehot:
            target_onehot = np.zeros(shape=(num_classes,))
            target_onehot[target] = 1
            target_ret = target_onehot.astype(np.float32)
        yield img.astype(np.float32), target_ret
def create_dataset(num_data=1024, batch_size=32, repeat_size=1):
    input_data = ds.GeneratorDataset(list(get_data(num_data)), column_names=['data', 'label'])
    input_data = input_data.batch(batch_size, drop_remainder=True)
    input_data = input_data.repeat(repeat_size)
    return input_data
ds_train = create_dataset()
# Initialize networknetwork = LeNet5(10)
# Define Loss and Optimizernet_loss = nn.SoftmaxCrossEntropyWithLogits(reduction="mean")

   4.真正使用Loss Scale的API接口，作用于优化器和模型中。

# Define Loss Scale, optimizer and model

#1) Drop the parameter update if there is an overflow

loss_scale_manager = ms.FixedLossScaleManager()

net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)

model = ms.Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()}, amp_level="O0", loss_scale_manager=loss_scale_manager)



#2) Execute parameter update even if overflow occurs

loss_scale = 1024.0

loss_scale_manager = ms.FixedLossScaleManager(loss_scale, False)

net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9, loss_scale=loss_scale)

model = ms.Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()}, amp_level="O0", loss_scale_manager=loss_scale_manager)



# Run training

model.train(epoch=10, train_dataset=ds_train, callbacks=[ms.LossMonitor()])



TotalTime = 0.639526, [19]
[parse]: 0.00137553
[symbol_resolve]: 0.0630952, [1]
    [Cycle 1]: 0.0626392, [1]
        [resolve]: 0.0626309
[combine_like_graphs]: 0.00123225
[inference_opt_prepare]: 0.000407694
[elininate_unused_parameter]: 0.000182617
[abstract_specialize]: 0.0623443
[auto_monad]: 0.00156646
[inline]: 1.93249e-06
[py_pre_ad]: 9.71369e-07
[pipeline_split]: 2.88989e-06
[optimize]: 0.477379, [14]
    [simplify_data_structures]: 0.00029841
    [opt_a]: 0.473795, [3]
        [Cycle 1]: 0.450451, [25]
            [expand_dump_flag]: 1.45491e-05
            [switch_simplify]: 0.000713205
            [a_1]: 0.00994622
            [recompute_prepare]: 8.40612e-05
            [updatestate_depend_eliminate]: 0.000666355
            [updatestate_assign_eliminate]: 6.59283e-05
            [updatestate_loads_eliminate]: 0.000232871
            [parameter_eliminate]: 2.64868e-06
...
 0.16% :     0.000156s :      1: opt.transforms.opt_after_cconv
 0.04% :     0.000044s :      1: opt.transforms.opt_b
 0.24% :     0.000240s :      1: opt.transforms.opt_trans_graph
 0.02% :     0.000018s :      1: opt.transforms.stop_gradient_special_op
epoch: 1 step: 32, loss is 2.301311731338501
epoch: 2 step: 32, loss is 2.2960867881774902
epoch: 3 step: 32, loss is 2.292977809906006
epoch: 4 step: 32, loss is 2.2935791015625
epoch: 5 step: 32, loss is 2.3079633712768555
epoch: 6 step: 32, loss is 2.3191769123077393
epoch: 7 step: 32, loss is 2.3069581985473633
epoch: 8 step: 32, loss is 2.2944517135620117
epoch: 9 step: 32, loss is 2.3150291442871094
epoch: 10 step: 32, loss is 2.3247132301330566

2、动态LossScale

LossScale在训练过程中可以动态改变scale值的大小，在没有发生溢出（此处为上溢出）的情况下，要尽可能保持较大的scale的值。如果发生了溢出（上溢出），将缩小scale的值。

名词解释：

**上溢出：**数值超出最大表示范围。如表示区间为0~65504，那么当进行50000 + 50000的操作时，则会发生上溢出，输出结果可能是65500。

**下溢出：**数值小于最小表示精度。如最小表示精度为6e-8，那么当进行8e-8 / 10的操作时，则会发生下溢出，输出结果可能是0。

DynamicLossScaleManager会首先将scale设置为一个初始值，该值由入参init_loss_scale控制。

在训练过程中，如果不发生溢出，在更新scale_window次参数后，会尝试扩大scale的值，如果发生了溢出，则跳过参数更新，并缩小scale的值，入参scale_factor是控制扩大或缩小的步数，scale_window控制没有发生溢出时，最大的连续更新步数。

具体用法如下，仅需将FixedLossScaleManager样例中定义LossScale，优化器和模型部分的代码改成如下代码：

# Define Loss Scale, optimizer and model

scale_factor = 4

scale_window = 3000

loss_scale_manager = ms.DynamicLossScaleManager(scale_factor, scale_window)

net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)

model = ms.Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()}, amp_level="O0", loss_scale_manager=loss_scale_manager)