mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/compression/__init__.py

@@ -1,19 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-MindSpore compression module.
-
-Note: This is an experimental interface that is subject to change and/or deletion.
-"""

mindspore/compression/common/constant.py

@@ -1,124 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Note:
-    Constant module for compression. This is interface that is subject to change or deletion.
-"""
-from __future__ import absolute_import
-
-import enum
-import re
-from types import DynamicClassAttribute
-
-
-__all__ = ["QuantDtype"]
-
-
-@enum.unique
-class QuantDtype(enum.Enum):
-    """
-    An enum for quant datatype, contains `INT2` ~ `INT8`, `UINT2` ~ `UINT8`.
-    """
-    INT2 = "INT2"
-    INT3 = "INT3"
-    INT4 = "INT4"
-    INT5 = "INT5"
-    INT6 = "INT6"
-    INT7 = "INT7"
-    INT8 = "INT8"
-
-    UINT2 = "UINT2"
-    UINT3 = "UINT3"
-    UINT4 = "UINT4"
-    UINT5 = "UINT5"
-    UINT6 = "UINT6"
-    UINT7 = "UINT7"
-    UINT8 = "UINT8"
-
-    def __str__(self):
-        return f"{self.name}"
-
-    @staticmethod
-    def is_signed(dtype):
-        """
-        Get whether the quant datatype is signed.
-
-        Args:
-            dtype (QuantDtype): quant datatype.
-
-        Returns:
-            bool, whether the input quant datatype is signed.
-
-        Examples:
-            >>> quant_dtype = QuantDtype.INT8
-            >>> is_signed = QuantDtype.is_signed(quant_dtype)
-        """
-        return dtype in [QuantDtype.INT2, QuantDtype.INT3, QuantDtype.INT4, QuantDtype.INT5,
-                         QuantDtype.INT6, QuantDtype.INT7, QuantDtype.INT8]
-
-    @staticmethod
-    def switch_signed(dtype):
-        """
-        Switch the signed state of the input quant datatype.
-
-        Args:
-            dtype (QuantDtype): quant datatype.
-
-        Returns:
-            QuantDtype, quant datatype with opposite signed state as the input.
-
-        Examples:
-            >>> quant_dtype = QuantDtype.INT8
-            >>> quant_dtype = QuantDtype.switch_signed(quant_dtype)
-        """
-        type_map = {
-            QuantDtype.INT2: QuantDtype.UINT2,
-            QuantDtype.INT3: QuantDtype.UINT3,
-            QuantDtype.INT4: QuantDtype.UINT4,
-            QuantDtype.INT5: QuantDtype.UINT5,
-            QuantDtype.INT6: QuantDtype.UINT6,
-            QuantDtype.INT7: QuantDtype.UINT7,
-            QuantDtype.INT8: QuantDtype.UINT8,
-            QuantDtype.UINT2: QuantDtype.INT2,
-            QuantDtype.UINT3: QuantDtype.INT3,
-            QuantDtype.UINT4: QuantDtype.INT4,
-            QuantDtype.UINT5: QuantDtype.INT5,
-            QuantDtype.UINT6: QuantDtype.INT6,
-            QuantDtype.UINT7: QuantDtype.INT7,
-            QuantDtype.UINT8: QuantDtype.INT8
-        }
-        return type_map.get(dtype)
-
-    @DynamicClassAttribute
-    def _value(self):
-        """The value of the Enum member."""
-        return int(re.search(r"(\d+)", self._value_).group(1))
-
-    @DynamicClassAttribute
-    def num_bits(self):
-        """
-        Get the num bits of the QuantDtype member.
-
-        Returns:
-            int, the num bits of the QuantDtype member.
-
-        Examples:
-            >>> from mindspore.compression.common import QuantDtype
-            >>> quant_dtype = QuantDtype.INT8
-            >>> num_bits = quant_dtype.num_bits
-            >>> print(num_bits)
-            8
-        """
-        return self._value

mindspore/compression/export/__init__.py

@@ -1,19 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Compression export module.
-
-Note: This is an experimental interface that is subject to change and/or deletion.
-"""

mindspore/compression/export/quant_export.py

@@ -1,515 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Note:
-    Export for quantization. This is interface that is subject to change or deletion.
-"""
-
-from __future__ import absolute_import
-
-import copy
-
-import numpy as np
-
-from mindspore import log as logger
-from mindspore import nn, ops
-from mindspore._checkparam import Validator
-from mindspore.common import Tensor
-from mindspore.common import dtype as mstype
-from mindspore.common.api import _cell_graph_executor as _executor
-from mindspore.common.parameter import Parameter
-from mindspore.nn import Cell
-from mindspore.nn.layer import quant
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
-from mindspore.ops.operations import _inner_ops as inner
-from mindspore.compression.quant import quant_utils
-from mindspore.compression.quant.qat import _AddFakeQuantInput, _AddFakeQuantAfterSubCell
-
-__all__ = ["ExportToQuantInferNetwork"]
-
-
-class QuantBlock(Cell):
-    r"""
-    A quant block of Conv/Dense, activation layer for Ascend deploy.
-
-    Calculate Conv or Dense in Int8, with Quant and DeQuant.
-
-    Notes:
-        This block is only for deploy, and not trainable.
-
-    Args:
-        in_channels (int): The number of channels in the input space.
-        out_channels (int): The number of channels in the output space.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
-            is same as input x. The values of str refer to the function `initializer`. Default: 'normal'.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
-            same as input x. The values of str refer to the function `initializer`. Default: 'zeros'.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: True.
-        activation (str): The regularization function applied to the output of the layer, eg. 'relu'. Default: None.
-        batchnorm (bool): Specifies to used batchnorm or not. Default: None.
-        activation (string): Specifies activation type. The optional values are as following:
-            'softmax', 'logsoftmax', 'relu', 'relu6', 'tanh', 'gelu', 'sigmoid',
-            'prelu', 'leakyrelu', 'hswish', 'hsigmoid'. Default: None.
-
-    Inputs:
-        - **input** (Tensor) - Tensor of shape :math:`(N, in\_channels)`.
-
-    Outputs:
-        Tensor of shape :math:`(N, out\_channels)`.
-    """
-
-    def __init__(self,
-                 core_op,
-                 weight,
-                 quant_op,
-                 dequant_op,
-                 dequant_scale,
-                 bias=None,
-                 activation=None):
-        super(QuantBlock, self).__init__()
-        self.core_op = core_op
-        self.weight = weight
-        self.quant = quant_op
-        self.dequant = dequant_op
-        self.dequant_scale = dequant_scale
-        self.bias = bias
-        self.has_bias = bias is not None
-        self.activation = activation
-        self.has_act = activation is not None
-        self.bias_add = P.BiasAdd()
-        self.sub = P.Sub()
-        self.weight_offset = Parameter(np.zeros(1, dtype=np.int8), name='weight_offset')
-
-    def construct(self, x):
-        x = self.quant(x)
-        if self.has_bias:
-            weight = self.sub(self.weight, self.weight_offset)
-            x = self.core_op(x, weight)
-            x = self.bias_add(x, self.bias)
-        else:
-            x = self.core_op(x, self.weight)
-        x = self.dequant(x, self.dequant_scale)
-        x = F.cast(x, mstype.float32)
-        if self.has_act:
-            x = self.activation(x)
-        return x
-
-    def extend_repr(self):
-        s = f'quant={self.quant}, core_op={type(self.core_op)}, weight=shape[{self.weight.shape}]'
-        if self.has_bias:
-            s += f', bias=shape[{self.bias.shape}]'
-        if self.has_act:
-            s += f', activation={self.activation}'
-        s += f', dequant={self.dequant}'
-        return s
-
-
-class QuantMindirBlock(Cell):
-    """A quant binary block of Conv/Dense, activation layer for export MINDIR model.
-
-       Args:
-        core_op (Cell): The operation cell.
-        weight (Tensor): The weight of the cell.
-        bias (Tensor): The bias of the cell. Default: None.
-        activation (str): The regularization function applied to the output of the layer, eg. 'relu'. Default: None.
-        param_dict (dict): The information of the cell.
-    """
-
-    def __init__(self,
-                 core_op,
-                 weight,
-                 bias=None,
-                 activation=None,
-                 param_dict=None):
-
-        super(QuantMindirBlock, self).__init__()
-        self.core_op = core_op
-        if activation is not None:
-            self.core_op.add_prim_attr("activation_name", activation.__class__.__name__)
-        self.core_op.add_prim_attr("filter_maxq", Tensor(param_dict["filter_maxq"]))
-        self.core_op.add_prim_attr("filter_minq", Tensor(param_dict["filter_minq"]))
-        if param_dict["output_maxq"] is not None:
-            self.core_op.add_prim_attr("output_maxq", Tensor(param_dict["output_maxq"]))
-            self.core_op.add_prim_attr("output_minq", Tensor(param_dict["output_minq"]))
-        self.core_op.add_prim_attr("symmetric", Tensor(param_dict["symmetric"]))
-        if hasattr(core_op, 'pad_mode'):
-            self.core_op.add_prim_attr("pad_mode", core_op.pad_mode)
-        self.core_op.add_prim_attr("act_num_bits", Tensor(8))
-        self.core_op.add_prim_attr("weight_num_bits", Tensor(param_dict["weight_num_bits"]))
-        self.core_op.add_prim_attr("weight_narrow_range", Tensor(param_dict["weight_narrow_range"]))
-        if param_dict["input_narrow_range"] is not None:
-            self.core_op.add_prim_attr("input_narrow_range", Tensor(param_dict["input_narrow_range"]))
-        if param_dict["output_narrow_range"] is not None:
-            self.core_op.add_prim_attr("output_narrow_range", Tensor(param_dict["output_narrow_range"]))
-        if param_dict["input_maxq"] == 'None':
-            self.core_op.add_prim_attr("mean", Tensor(param_dict["mean"]))
-            self.core_op.add_prim_attr("std_dev", Tensor(param_dict["std_dev"]))
-        elif param_dict["input_maxq"] is not None:
-            self.core_op.add_prim_attr("input_maxq", Tensor(param_dict["input_maxq"]))
-            self.core_op.add_prim_attr("input_minq", Tensor(param_dict["input_minq"]))
-
-        self.weight = weight
-        self.bias = bias
-        self.has_bias = bias is not None
-        self.activation = activation
-        self.has_act = activation is not None
-        self.bias_add = P.BiasAdd()
-
-    def construct(self, x):
-        if self.has_bias:
-            x = self.core_op(x, self.weight)
-            x = self.bias_add(x, self.bias)
-        else:
-            x = self.core_op(x, self.weight)
-        if self.has_act:
-            x = self.activation(x)
-        return x
-
-    def extend_repr(self):
-        s = f'core_op={type(self.core_op)}, weight=shape[{self.weight.shape}]'
-        if self.has_bias:
-            s += f', bias=shape[{self.bias.shape}]'
-        if self.has_act:
-            s += f', activation={self.activation}'
-        return s
-
-
-class ExportToQuantInferNetwork:
-    """
-    Convert quantization aware network to infer network.
-
-    Args:
-        network (Cell): MindSpore quantization aware training network.
-        inputs (Tensor): Input tensors of the `quantization aware training network`.
-        mean (int, float): The mean of input data after preprocessing, used for quantizing the first layer of network.
-          Default: 127.5.
-        std_dev (int, float): The variance of input data after preprocessing, used for quantizing the first layer
-          of network. Default: 127.5.
-        is_mindir (bool): Whether export MINDIR format. Default: False.
-
-    Returns:
-        Cell, Infer network.
-    """
-
-    def __init__(self, network, mean, std_dev, *inputs, is_mindir=False):
-        network = Validator.check_isinstance('network', network, (nn.Cell,))
-        self.data_type = mstype.int8
-        self.network = copy.deepcopy(network)
-        self.network_bk = copy.deepcopy(network)
-        self.get_inputs_table(inputs)
-        self.mean = mean
-        self.std_dev = std_dev
-        self.is_mindir = is_mindir
-        self.upcell = None
-
-    @staticmethod
-    def __get_dequant_scale(scale_a_in, scale_w):
-        """Get dequant scale"""
-        scale_deq = scale_a_in * scale_w
-
-        # fuse parameter
-        # |--------|47:40|--------|39:32|--------|31:0|
-        #         offset_w [8]    shift_N [8]    deq_scale [32]
-        float32_deq_scale = scale_deq.astype(np.float32)
-        uint32_deq_scale = np.frombuffer(float32_deq_scale, np.uint32)
-        scale_length = scale_deq.size  # channel
-        dequant_param = np.zeros(scale_length, dtype=np.uint64)
-        for index in range(scale_length):
-            dequant_param[index] += uint32_deq_scale[index]
-        scale_deq = Tensor(dequant_param, mstype.uint64)
-        return scale_deq
-
-    def get_inputs_table(self, inputs):
-        """Get the input quantization parameters of quantization cell for quant export."""
-        phase_name = 'export_quant'
-        graph_id, _ = _executor.compile(self.network, *inputs, phase=phase_name, do_convert=False)
-        self.quant_info_table = _executor.fetch_info_for_quant_export(graph_id)
-
-    def run(self):
-        """Start to convert."""
-        logger.warning("The compression module is deprecated and may not be supported in later version, please use "
-                       "MindSpore Golden Stick(https://gitee.com/mindspore/golden-stick) instead.")
-        self.network.update_cell_prefix()
-        network = self.network
-        if isinstance(network, _AddFakeQuantInput):
-            network = network.network
-        network = self._convert_quant2deploy(network)
-        return network
-
-    def _get_quant_block(self, cell_core, activation, fake_quant_a_out):
-        """convert network's quant subcell to deploy subcell"""
-        scale_a_in, zp_a_in, scale_w, zp_w, param_dict = self.__get_quant_param(cell_core, fake_quant_a_out)
-
-        # Build the `Quant` `Dequant` op.
-        # Quant only support perlayer version. Need check here.
-        if float(scale_a_in) == 0:
-            raise ValueError("If `scale_a_in` is zero, will lead to zero error.")
-        quant_op = inner.Quant(1 / float(scale_a_in), float(zp_a_in))
-        scale_deq = self.__get_dequant_scale(scale_a_in, scale_w)
-        dequant_op = inner.Dequant()
-
-        if isinstance(activation, _AddFakeQuantAfterSubCell):
-            activation = activation.subcell
-        elif hasattr(activation, "get_origin"):
-            activation = activation.get_origin()
-
-        # get op
-        if isinstance(cell_core, quant.DenseQuant):
-            op_core = P.MatMul()
-        else:
-            op_core = cell_core.conv
-
-        # get the `weight` and `bias`
-        weight, bias, weight_b, bias_b = self.__get_weight_bias(cell_core, scale_a_in, scale_w, zp_w)
-
-        if self.is_mindir:
-            block = QuantMindirBlock(op_core, weight_b, bias_b, activation, param_dict)
-        else:
-            block = QuantBlock(op_core, weight, quant_op, dequant_op, scale_deq, bias, activation)
-        return block
-
-    def _get_input_quant_param(self, minq_name, np_type, param_dict):
-        """get input quant parameter for quant block"""
-        fake_quant_a_in_prefix = minq_name[:-5]
-        cells = self.network_bk.cells_and_names()
-        for cell in cells:
-            if cell[0].endswith(fake_quant_a_in_prefix):
-                fake_quant_a_in = cell[1]
-                break
-        scale_a_in, zp_a_in, param_dict["input_maxq"], param_dict["input_minq"] = \
-            quant_utils.scale_zp_max_min_from_fake_quant_cell(fake_quant_a_in, np_type)
-        param_dict["input_narrow_range"] = fake_quant_a_in.narrow_range
-        return scale_a_in, zp_a_in
-
-    def __get_quant_param(self, cell_core, fake_quant_a_out):
-        """get parameter for quant block"""
-        w_minq_name = cell_core.fake_quant_weight.minq.name
-        w_maxq_name = cell_core.fake_quant_weight.maxq.name
-        np_type = mstype.dtype_to_nptype(self.data_type)
-        param_dict = dict()
-        param_dict["filter_maxq"] = None
-        param_dict["filter_minq"] = None
-        param_dict["output_maxq"] = None
-        param_dict["output_minq"] = None
-        param_dict["input_maxq"] = None
-        param_dict["input_minq"] = None
-        param_dict["input_narrow_range"] = None
-        param_dict["output_narrow_range"] = None
-        param_dict["weight_narrow_range"] = cell_core.fake_quant_weight.narrow_range
-        param_dict["mean"] = self.mean
-        param_dict["std_dev"] = self.std_dev
-        param_dict["symmetric"] = cell_core.fake_quant_weight.symmetric
-        param_dict["weight_num_bits"] = cell_core.fake_quant_weight.num_bits
-
-        scale_w, zp_w, param_dict["filter_maxq"], param_dict["filter_minq"] = \
-            quant_utils.scale_zp_max_min_from_fake_quant_cell(cell_core.fake_quant_weight, np_type)
-        if fake_quant_a_out is not None:
-            _, _, param_dict["output_maxq"], param_dict["output_minq"] = \
-                quant_utils.scale_zp_max_min_from_fake_quant_cell(fake_quant_a_out, np_type)
-            param_dict["output_narrow_range"] = fake_quant_a_out.narrow_range
-
-        info = self.quant_info_table.get(w_minq_name, None)
-        if not info:
-            info = self.quant_info_table.get(w_maxq_name, None)
-        if info:
-            _, minq_name = info
-            if minq_name == 'input':
-                scale_a_in, zp_a_in, param_dict["input_maxq"], param_dict["input_minq"] = \
-                    (1 / self.std_dev), round(self.mean), 'None', 'None'
-            else:
-                scale_a_in, zp_a_in = self._get_input_quant_param(minq_name, np_type, param_dict)
-        else:
-            # skip quant layer
-            scale_a_in, zp_a_in = 1.0, 0.0
-        return scale_a_in, zp_a_in, scale_w, zp_w, param_dict
-
-    def __get_weight_bias(self, cell_core, scale_a_in, scale_w, zp_w):
-        """Get weight and bias for quantizaiton"""
-        np_type = mstype.dtype_to_nptype(self.data_type)
-        weight = cell_core.weight.data.asnumpy()
-        bias = None
-        if isinstance(cell_core, (quant.DenseQuant, quant.Conv2dQuant)):
-            if cell_core.has_bias:
-                bias = cell_core.bias.data.asnumpy()
-        elif isinstance(cell_core, (quant.Conv2dBnFoldQuant, quant.Conv2dBnFoldQuantOneConv)):
-            weight, bias = quant_utils.fold_batchnorm(weight, cell_core)
-        elif isinstance(cell_core, quant.Conv2dBnWithoutFoldQuant):
-            weight, bias = quant_utils.without_fold_batchnorm(weight, cell_core)
-        weight_b = weight
-        bias_b = bias
-        # apply the quant
-        quant_min, quant_max = quant_utils.get_quant_min_max(np_type,
-                                                             cell_core.fake_quant_weight.num_bits,
-                                                             cell_core.fake_quant_weight.narrow_range)
-        weight = quant_utils.weight2int(weight, scale_w, zp_w, quant_min, quant_max)
-        if bias is not None:
-            if 0 in scale_a_in:
-                raise ValueError("Zero exist in `scale_a_in` which will lead to divide zero error.")
-            if 0 in scale_w:
-                raise ValueError("Zero exist in `scale_w` which will lead to divide zero error.")
-            bias = Tensor(bias / scale_a_in / scale_w, mstype.int32)
-
-        if isinstance(cell_core, quant.DenseQuant):
-            weight = np.transpose(weight)
-            weight_b = np.transpose(weight_b)
-
-        weight_tensor = Tensor(weight, self.data_type)
-        weight_b_tensor = Tensor(weight_b)
-        if bias_b is not None:
-            bias_b_tensor = Tensor(bias_b, mstype.float32)
-            return weight_tensor, bias, weight_b_tensor, bias_b_tensor
-        return weight_tensor, bias, weight_b_tensor, None
-
-    def _add_output_min_max_for_op(self, origin_op, fake_quant_cell):
-        """add output quant info for quant op for export mindir."""
-        if self.is_mindir:
-            if isinstance(origin_op, ops.Primitive) and not hasattr(origin_op, 'output_minq'):
-                np_type = mstype.dtype_to_nptype(self.data_type)
-                _, _, maxq, minq = quant_utils.scale_zp_max_min_from_fake_quant_cell(fake_quant_cell, np_type)
-                origin_op.add_prim_attr('output_maxq', Tensor(maxq))
-                origin_op.add_prim_attr('output_minq', Tensor(minq))
-
-    def _convert_subcell(self, network, change, name, subcell):
-        """Convert subcell to ant subcell."""
-        if subcell is not None and hasattr(subcell, "fake_quant_weight"):
-            new_subcell = self._get_quant_block(subcell, None, None)
-            prefix = subcell.param_prefix
-            new_subcell.update_parameters_name(prefix + '.')
-            self.upcell = new_subcell
-            network.insert_child_to_cell(name, new_subcell)
-            change = True
-        return network, change
-
-    def _convert_conv(self, network, change, name, subcell):
-        """Convert subcell to ant subcell for conv."""
-        cell_core = subcell.conv
-        activation = subcell.activation
-        fake_quant_act = None
-        if hasattr(activation, 'fake_quant_act_before'):
-            fake_quant_act = activation.fake_quant_act_before
-        elif hasattr(activation, 'fake_quant_act'):
-            fake_quant_act = activation.fake_quant_act
-        if cell_core is not None and hasattr(cell_core, "fake_quant_weight"):
-            new_subcell = self._get_quant_block(cell_core, activation, fake_quant_act)
-            self.upcell = None
-            prefix = subcell.param_prefix
-            new_subcell.update_parameters_name(prefix + '.')
-            network.insert_child_to_cell(name, new_subcell)
-            change = True
-        return network, change
-
-    def _convert_dense(self, network, change, name, subcell):
-        """Convert subcell to ant subcell for dense."""
-        cell_core = subcell.dense
-        activation = subcell.activation
-        fake_quant_act = None
-        if hasattr(activation, 'fake_quant_act_before'):
-            fake_quant_act = activation.fake_quant_act_before
-        elif hasattr(activation, 'fake_quant_act'):
-            fake_quant_act = activation.fake_quant_act
-        if cell_core is not None and hasattr(cell_core, "fake_quant_weight"):
-            new_subcell = self._get_quant_block(cell_core, activation, fake_quant_act)
-            prefix = subcell.param_prefix
-            new_subcell.update_parameters_name(prefix + '.')
-            network.insert_child_to_cell(name, new_subcell)
-            self.upcell = None
-            change = True
-        return network, change
-
-    def _convert_act(self, subcell):
-        """Convert subcell to ant subcell for activation."""
-        activation = subcell.get_origin()
-        if isinstance(activation, nn.ReLU):
-            self._add_output_min_max_for_op(activation.relu, subcell.fake_quant_act)
-        elif isinstance(activation, nn.ReLU6):
-            self._add_output_min_max_for_op(activation.relu6, subcell.fake_quant_act)
-        if self.upcell:
-            self._add_output_min_max_for_op(self.upcell.core_op, subcell.fake_quant_act)
-        return activation
-
-    def _convert_add(self, subcell):
-        """Convert subcell to ant subcell for add."""
-        if isinstance(subcell.add, _AddFakeQuantAfterSubCell):
-            add_op = subcell.add.subcell
-            subcell.__delattr__("add")
-            subcell.__setattr__("add", add_op)
-        add_op = subcell.add
-        self._add_output_min_max_for_op(add_op, subcell.fake_quant_act)
-        subcell.__delattr__("fake_quant_act")
-        subcell.__setattr__("fake_quant_act", P.identity())
-
-    def _convert_observer(self, network, name, subcell):
-        """Convert subcell to ant subcell for FakeQuantWithMinMaxObserver."""
-        if self.upcell:
-            self._add_output_min_max_for_op(self.upcell.core_op, subcell)
-        network.__delattr__(name)
-        network.__setattr__(name, P.identity())
-
-    def _convert_fake_quant_after_cell(self, network, name, subcell):
-        """Convert subcell to ant subcell for _AddFakeQuantAfterSubCell."""
-        op = subcell.subcell
-        self._add_output_min_max_for_op(op, subcell.fake_quant_act)
-        network.__delattr__(name)
-        network.__setattr__(name, op)
-
-    def _convert_core_quant_subcell(self, network, change, name, subcell):
-        """Convert subcell to ant subcell for conv and dense."""
-        is_core_subcell = True
-        if isinstance(subcell, nn.Conv2dBnAct):
-            network, change = self._convert_conv(network, change, name, subcell)
-        elif isinstance(subcell, nn.DenseBnAct):
-            network, change = self._convert_dense(network, change, name, subcell)
-        elif isinstance(subcell, (quant.Conv2dBnFoldQuant, quant.Conv2dBnFoldQuantOneConv,
-                                  quant.Conv2dBnWithoutFoldQuant, quant.Conv2dQuant, quant.DenseQuant)):
-            network, change = self._convert_subcell(network, change, name, subcell)
-        else:
-            is_core_subcell = False
-        return is_core_subcell, network, change
-
-    def _convert_other_quant_subcell(self, network, change, name, subcell):
-        """Convert subcell to ant subcell for cell except conv and dense."""
-        is_other_subcell = True
-        if isinstance(subcell, nn.ActQuant) and hasattr(subcell, "get_origin"):
-            activation = self._convert_act(subcell)
-            network.insert_child_to_cell(name, activation)
-            change = True
-        elif isinstance(subcell, nn.TensorAddQuant):
-            self._convert_add(subcell)
-        elif isinstance(subcell, quant.FakeQuantWithMinMaxObserver):
-            self._convert_observer(network, name, subcell)
-        elif isinstance(subcell, _AddFakeQuantAfterSubCell):
-            self._convert_fake_quant_after_cell(network, name, subcell)
-            change = True
-        else:
-            is_other_subcell = False
-        return is_other_subcell, network, change
-
-    def _convert_quant2deploy(self, network):
-        """Convert network's all quant subcell to deploy subcell."""
-        cells = network.name_cells()
-        change = False
-        for name in cells:
-            subcell = cells[name]
-            if subcell == network:
-                continue
-            is_core_quant_subcell, network, change = self._convert_core_quant_subcell(network, change, name, subcell)
-            is_other_quant_subcell, network, change = self._convert_other_quant_subcell(network, change, name, subcell)
-            if not is_core_quant_subcell and not is_other_quant_subcell:
-                self.upcell = None
-                self._convert_quant2deploy(subcell)
-        if isinstance(network, nn.SequentialCell) and change:
-            network.cell_list = list(network.cells())
-        return network