mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/train/serialization.py

@@ -18,7 +18,6 @@ from __future__ import absolute_import
 from __future__ import division
 
 import copy
-import functools
 import json
 import os
 import shutil
@@ -41,24 +40,28 @@ import mindspore
 import mindspore.nn as nn
 from mindspore import context
 from mindspore import log as logger
-from mindspore._checkparam import check_input_data, check_input_dataset, Validator
+from mindspore._checkparam import check_input_data, check_input_dataset
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from mindspore.common.api import _cell_graph_executor as _executor
+from mindspore.common.api import _MindsporeFunctionExecutor
+from mindspore.common.api import _get_parameter_layout
+from mindspore.common.api import _generate_branch_control_input
 from mindspore.common.initializer import initializer, One
 from mindspore.common.parameter import Parameter
 from mindspore.common.tensor import Tensor
 from mindspore.common._utils import is_shape_unknown
 from mindspore.communication.management import get_rank, get_group_size
-from mindspore.compression.export import quant_export
+from mindspore.experimental import MapParameter
 from mindspore.parallel._cell_wrapper import get_allgather_cell
 from mindspore.parallel._tensor import _load_tensor, _get_tensor_strategy, _get_tensor_slice_index
 from mindspore.parallel._tensor import _reshape_param_data, _reshape_param_data_with_weight
-from mindspore.parallel._utils import _infer_rank_list, _remove_repeated_slices
-from mindspore.parallel._parallel_serialization import _convert_to_list, _convert_to_layout, _build_searched_strategy,\
+from mindspore.parallel._utils import _infer_rank_list, _remove_repeated_slices, _is_in_auto_parallel_mode
+from mindspore.parallel._parallel_serialization import _convert_to_list, _convert_to_layout, _build_searched_strategy, \
     _restore_group_info_list
 from mindspore.train._utils import read_proto
-from mindspore._c_expression import load_mindir, _encrypt, _decrypt, _is_cipher_file
-
+from mindspore._c_expression import load_mindir, _encrypt, _decrypt, _is_cipher_file, dynamic_obfuscate_mindir
+from ..ops.operations._opaque_predicate_registry import add_opaque_predicate, clean_funcs
 
 tensor_to_ms_type = {"Int8": mstype.int8, "UInt8": mstype.uint8, "Int16": mstype.int16, "UInt16": mstype.uint16,
                      "Int32": mstype.int32, "UInt32": mstype.uint32, "Int64": mstype.int64, "UInt64": mstype.uint64,
@@ -81,6 +84,7 @@ PROTO_LIMIT_SIZE = 1024 * 1024 * 2
 TOTAL_SAVE = 1024 * 1024
 PARAMETER_SPLIT_SIZE = 1024 * 1024 * 1024
 ENCRYPT_BLOCK_SIZE = 64 * 1024
+INT_64_MAX = 9223372036854775807
 
 
 def _special_process_par(par, new_par):
@@ -213,6 +217,13 @@ def _exec_save(ckpt_file_name, data_list, enc_key=None, enc_mode="AES-GCM"):
                     plain_data = BytesIO()
 
                 for name, value in data_list.items():
+                    if value[0] == "mapparameter":
+                        _write_mapparameter(name, value, f)
+                        continue
+                    if isinstance(value[2], Tensor):
+                        _write_hugeparameter(name, value, f)
+                        continue
+
                     data_size = value[2].nbytes / 1024
                     if data_size > SLICE_SIZE:
                         slice_count = math.ceil(data_size / SLICE_SIZE)
@@ -250,6 +261,41 @@ def _exec_save(ckpt_file_name, data_list, enc_key=None, enc_mode="AES-GCM"):
         raise e
 
 
+def _write_mapparameter(name, value, f):
+    """Write map parameter into protobuf file."""
+    checkpoint_list = Checkpoint()
+    param_value = checkpoint_list.value.add()
+    param_value.tag = name
+    map_tensor = param_value.maptensor
+    for v in value[1:]:
+        tensor = map_tensor.tensor.add()
+        tensor.dims.extend(v[0])
+        tensor.tensor_type = v[1]
+        tensor.tensor_content = v[2].tobytes()
+        f.write(checkpoint_list.SerializeToString())
+
+
+def _write_hugeparameter(name, value, f):
+    """Write huge parameter into protobuf file."""
+    slice_num = value[2].slice_num
+    offset = 0
+    max_size = value[0][0]
+    for param_slice in range(slice_num):
+        checkpoint_list = Checkpoint()
+        param_value = checkpoint_list.value.add()
+        param_value.tag = name
+        param_tensor = param_value.tensor
+        param_tensor.dims.extend(value[0])
+        param_tensor.tensor_type = value[1]
+        param_key = value[3]
+        numpy_data = value[2].asnumpy_of_slice_persistent_data(param_key, param_slice)
+        if offset + numpy_data.shape[0] > max_size:
+            numpy_data = numpy_data[:max_size - offset]
+        param_tensor.tensor_content = numpy_data.tobytes()
+        f.write(checkpoint_list.SerializeToString())
+        offset += numpy_data.shape[0]
+
+
 def _check_save_obj_and_ckpt_file_name(save_obj, ckpt_file_name):
     """Check save_obj and ckpt_file_name for save_checkpoint."""
     if not isinstance(save_obj, nn.Cell) and not isinstance(save_obj, list):
@@ -259,7 +305,7 @@ def _check_save_obj_and_ckpt_file_name(save_obj, ckpt_file_name):
         raise TypeError("For 'save_checkpoint', the parameter {} for checkpoint file name is invalid,"
                         "'ckpt_file_name' must be "
                         "string, but got {}.".format(ckpt_file_name, type(ckpt_file_name)))
-    ckpt_file_name = os.path.realpath(ckpt_file_name)
+    ckpt_file_name = os.path.abspath(ckpt_file_name)
     if os.path.isdir(ckpt_file_name):
         raise IsADirectoryError("For 'save_checkpoint', the parameter `ckpt_file_name`: {} is a directory, "
                                 "it must be a file name.".format(ckpt_file_name))
@@ -286,7 +332,7 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
         enc_key (Union[None, bytes]): Byte type key used for encryption. If the value is None, the encryption
                                       is not required. Default: None.
         enc_mode (str): This parameter is valid only when enc_key is not set to None. Specifies the encryption
-                        mode, currently supports 'AES-GCM' and 'AES-CBC'. Default: 'AES-GCM'.
+                        mode, currently supports 'AES-GCM' and 'AES-CBC' and 'SM4-CBC'. Default: 'AES-GCM'.
 
     Raises:
         TypeError: If the parameter save_obj is not `nn.Cell` or list type. And if the parameter `integrated_save`
@@ -308,6 +354,9 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
     logger.info("Execute the process of saving checkpoint files.")
 
     if isinstance(save_obj, nn.Cell):
+        parameter_layout_dict = save_obj.parameter_layout_dict
+        if _is_in_auto_parallel_mode() and not parameter_layout_dict:
+            parameter_layout_dict = _get_parameter_layout()
         save_obj.init_parameters_data()
         param_dict = OrderedDict()
         for _, param in save_obj.parameters_and_names():
@@ -315,12 +364,28 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
         param_list = []
         for (key, value) in param_dict.items():
             each_param = {"name": key}
-            param_data = Tensor(value.data.asnumpy())
+            if isinstance(value, MapParameter):
+                param_data = []
+                for export_data in value.export_data():
+                    param_data.append(Tensor(export_data))
+                    each_param["data"] = param_data
+                    param_list.append(each_param)
+                continue
+
+            if value.data.is_persistent_data():
+                # list save persistent_data: [Tensor, shape, type, param.key]
+                param_data = ["persistent_data"]
+                param_data.append(value.data)
+                param_data.append(value.param_info.origin_shape)
+                param_data.append(str(value.dtype))
+                param_data.append(value.key)
+            else:
+                param_data = Tensor(value.data.asnumpy())
 
             # in automatic model parallel scenario, some parameters were split to all the devices,
             # which should be combined before saving
-            if key in save_obj.parameter_layout_dict:
-                param_data = _get_merged_param_data(save_obj, key, param_data, integrated_save)
+            if key in parameter_layout_dict:
+                param_data = _get_merged_param_data(save_obj, parameter_layout_dict, key, param_data, integrated_save)
 
             each_param["data"] = param_data
             param_list.append(each_param)
@@ -339,6 +404,12 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
         for param in save_obj:
             key = param["name"]
             data_list[key] = []
+            if isinstance(param["data"], list):
+                if param["data"][0] == "persistent_data":
+                    _save_persistent_data(data_list, key, param)
+                else:
+                    _save_mapparameter(data_list, param)
+                continue
             if isinstance(param["data"], str):
                 data_list[key].append([0])
                 data_list[key].append('str')
@@ -369,6 +440,34 @@ def save_checkpoint(save_obj, ckpt_file_name, integrated_save=True,
     logger.info("Saving checkpoint process is finished.")
 
 
+def _save_mapparameter(data_list, param):
+    """Save map parameter into save_obj."""
+    data_list[param["name"]].append("mapparameter")
+    for value in param["data"]:
+        dims = []
+        tmp_list = []
+        for dim in value.shape:
+            dims.append(dim)
+        tmp_list.append(dims)
+        tensor_type = str(value.dtype)
+        tmp_list.append(tensor_type)
+        data = value.asnumpy().reshape(-1)
+        tmp_list.append(data)
+        data_list[param["name"]].append(tmp_list)
+
+
+def _save_persistent_data(data_list, key, param):
+    """Save persistent data into save_obj."""
+    dims = []
+    # persistent_data shape can not be ()
+    for dim in param['data'][2]:
+        dims.append(dim)
+    data_list[key].append(dims)
+    data_list[key].append(param['data'][3])
+    data_list[key].append(param['data'][1])
+    data_list[key].append(param['data'][4])
+
+
 def _check_append_dict(append_dict):
     """Check the argument append_dict for save_checkpoint."""
     if append_dict is None:
@@ -383,6 +482,15 @@ def _check_append_dict(append_dict):
     return append_dict
 
 
+def _check_load_obfuscate(**kwargs):
+    if 'obf_func' in kwargs.keys():
+        customized_func = _check_customized_func(kwargs.get('obf_func'))
+        clean_funcs()
+        add_opaque_predicate(customized_func.__name__, customized_func)
+        return True
+    return False
+
+
 def load(file_name, **kwargs):
     """
     Load MindIR.
@@ -397,9 +505,14 @@ def load(file_name, **kwargs):
             - dec_key (bytes): Byte-type key used for decryption. The valid length is 16, 24, or 32.
             - dec_mode (Union[str, function]): Specifies the decryption mode, to take effect when dec_key is set.
 
-              - Option: 'AES-GCM', 'AES-CBC' or customized decryption. Default: 'AES-GCM'.
+              - Option: 'AES-GCM', 'AES-CBC', 'SM4-CBC' or customized decryption. Default: 'AES-GCM'.
               - For details of using the customized decryption, please check the `tutorial
-                <https://mindspore.cn/mindarmour/docs/en/r1.10/model_encrypt_protection.html>`_.
+                <https://mindspore.cn/mindarmour/docs/en/r2.0/model_encrypt_protection.html>`_.
+
+            - obf_func (function): A python function used for loading obfuscated MindIR model, which can refer to
+              `obfuscate_model()
+              <https://www.mindspore.cn/docs/en/r2.0/api_python/mindspore/mindspore.obfuscate_model.html>` .
+
     Returns:
         GraphCell, a compiled graph that can executed by `GraphCell`.
 
@@ -412,6 +525,8 @@ def load(file_name, **kwargs):
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor
+        >>> from mindspore import context
+        >>> context.set_context(mode=context.GRAPH_MODE)
         >>>
         >>> net = nn.Conv2d(1, 1, kernel_size=3, weight_init="ones")
         >>> input_tensor = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
@@ -433,7 +548,10 @@ def load(file_name, **kwargs):
     if not os.path.exists(file_name):
         raise ValueError("For 'load', the argument 'file_name'(MindIR file) does not exist, "
                          "please check whether the 'file_name' is correct.")
-    file_name = os.path.realpath(file_name)
+    file_name = os.path.abspath(file_name)
+
+    # set customized functions for dynamic obfuscation
+    obfuscated = _check_load_obfuscate(**kwargs)
 
     logger.info("Execute the process of loading mindir.")
     if 'dec_key' in kwargs.keys():
@@ -447,9 +565,9 @@ def load(file_name, **kwargs):
             else:
                 dec_mode = Validator.check_isinstance('dec_mode', kwargs.get('dec_mode'), str)
         graph = load_mindir(file_name, dec_key=dec_key, key_len=len(dec_key), dec_mode=dec_mode,
-                            decrypt=dec_func)
+                            decrypt=dec_func, obfuscated=obfuscated)
     else:
-        graph = load_mindir(file_name)
+        graph = load_mindir(file_name, obfuscated=obfuscated)
 
     if graph is None:
         if _is_cipher_file(file_name):
@@ -460,14 +578,187 @@ def load(file_name, **kwargs):
     return graph
 
 
+def _check_param_type(param_config, key, target_type, requested):
+    """check type of parameters"""
+    if key in param_config:
+        if not isinstance(param_config[key], target_type):
+            raise TypeError("The type of {} must be {}, but got {}.".format(key, target_type, type(param_config[key])))
+        if key == 'obf_random_seed':
+            if param_config[key] > INT_64_MAX or param_config[key] <= 0:
+                raise ValueError(
+                    "'obf_random_seed' must be in (0, INT_64_MAX({})], but got {}.".format(INT_64_MAX,
+                                                                                           param_config[key]))
+        return param_config[key]
+    if requested:
+        raise ValueError("The parameter {} is requested, but not got.".format(key))
+    if key == "obf_random_seed":
+        return 0
+    return None
+
+
+def _check_customized_func(customized_func):
+    """ check customized function of dynamic obfuscation """
+    if not callable(customized_func):
+        raise TypeError(
+            "'customized_func' must be a function, but not got {}.".format(type(customized_func)))
+    # test customized_func
+    try:
+        func_result = customized_func(1.0, 1.0)
+    except Exception as ex:
+        raise TypeError("customized_func must be a function with two inputs, but got exception: {}".format(ex))
+    else:
+        if not isinstance(func_result, bool):
+            raise TypeError("Return value of customized_func must be boolean, but got: {}".format(type(func_result)))
+    return customized_func
+
+
+def _check_obfuscate_params(obf_config):
+    """Check obfuscation parameters, including obf_random_seed, obf_ratio, customized_func"""
+    if 'obf_random_seed' not in obf_config.keys() and 'customized_func' not in obf_config.keys():
+        raise ValueError(
+            "At least one of 'obf_random_seed' or 'customized_func' must be set in obf_config, but got None of them.")
+    obfuscate_type = _check_param_type(obf_config, "type", str, False)
+    if obfuscate_type not in (None, "dynamic"):
+        raise ValueError("Only 'dynamic' type is supported by now, but got {}.".format(obfuscate_type))
+    if ('obf_ratio' in obf_config) and isinstance(obf_config['obf_ratio'], str):
+        if obf_config['obf_ratio'] not in ["small", "medium", "large"]:
+            raise ValueError("'obf_ratio' can only be 'small', 'medium', 'large' or float, but got {}.".format(
+                obf_config['obf_ratio']))
+        ratio_dict = {"small": 0.1, "medium": 0.3, "large": 0.6}
+        obf_config['obf_ratio'] = ratio_dict.get(obf_config['obf_ratio'])
+    obf_ratio = _check_param_type(obf_config, "obf_ratio", float, True)
+    if (obf_ratio <= 0) or (obf_ratio > 1):
+        raise ValueError("'obf_ratio' must be in (0, 1] if it is a float, but got {}.".format(obf_config['obf_ratio']))
+    customized_funcs = []
+    if 'customized_func' in obf_config.keys():
+        device_target = context.get_context('device_target')
+        if device_target in ["GPU", "Ascend"]:
+            raise ValueError(
+                "Customized func mode only support 'device_target'='CPU, but got {}.".format(device_target))
+        customized_funcs.append(_check_customized_func(obf_config['customized_func']))
+    obf_random_seed = _check_param_type(obf_config, "obf_random_seed", int, False)
+    return obf_ratio, customized_funcs, obf_random_seed
+
+
+def obfuscate_model(obf_config, **kwargs):
+    """
+    Obfuscate a model of MindIR format. Obfuscation means changing the struct of a network without affecting its
+    predict correctness. The obfuscated model can prevent attackers from stealing the model.
+
+    Args:
+        obf_config (dict): obfuscation config.
+
+            - type (str): The type of obfuscation, only 'dynamic' is supported until now.
+            - original_model_path (str): The path of MindIR format model that need to be obfuscated. If the original
+              model is encrypted, then enc_key and enc_mode should be provided.
+            - save_model_path (str): The path to save the obfuscated model.
+            - model_inputs (list(Tensor)): The inputs of the original model, the values of Tensor can be random, which
+              is the same as using :func:`mindspore.export`.
+            - obf_ratio (Union(float, str)): The ratio of nodes in original model that would be obfuscated. `obf_ratio`
+              should be in range of (0, 1] or in ["small", "medium", "large"].
+            - customized_func (function): A python function used for customized function mode, which used for control
+              the switch branch of obfuscation structure. The outputs of customized_func should be boolean. This
+              function needs to ensure that its result is constant for any input. Users can refer to opaque
+              predicates. If customized_func is set, then it should be passed to :func:`mindspore.load` interface
+              when loading obfuscated model.
+            - obf_random_seed (int): The random seed used for determine the distribution of confusion branches and the
+              weight confusion coefficient, which should be in (0, 9223372036854775807]. If `obf_random_seed` is set,
+              then it should be passed to :class:`nn.GraphCell()` interface when loading obfuscated model. It should be
+              noted that at least one of `customized_func` or `obf_random_seed` should be set, and the latter mode
+              would be applied if both of them are set.
+
+        kwargs (dict): Configuration options dictionary.
+
+            - enc_key (bytes): Byte type key used for encryption. The valid length is 16, 24, or 32.
+            - enc_mode (str): Specifies the encryption mode, to take effect when dec_key is set.
+              Option: 'AES-GCM' | 'AES-CBC' | 'SM4-CBC'. Default: 'AES-GCM'.
+
+    Raises:
+        TypeError: If `obf_config` is not a dict.
+        ValueError: If `enc_key` is passed and `enc_mode` is not in ["AES-GCM", "AES-CBC", "SM4-CBC"].
+        ValueError: If `original_model_path` is not provided in `obf_config`.
+        ValueError: If the model saved in `original_model_path` has been obfuscated.
+        ValueError: If `save_model_path` is not provided in `obf_config`.
+        ValueError: If `obf_ratio` is not provided in `obf_config`.
+        ValueError: If both `customized_func` and `obf_random_seed` are not provided in `obf_config`.
+        ValueError: If `obf_random_seed` is not in (0, 9223372036854775807].
+        ValueError: If `original_model_path` is not exist or `original_model_path` is not end with '.mindir'.
+
+    Examples:
+        >>> obf_config = {'original_model_path': "./net.mindir",
+        ...          'save_model_path': "./obf_net",
+        ...          'model_inputs': [input1, ],
+        ...          'obf_ratio': 0.1, 'obf_random_seed': 173262358423}
+        >>> obfuscate_model(obf_config)
+        >>> obf_func = load("obf_net.mindir")
+        >>> obf_net = nn.GraphCell(obf_func, obf_random_seed=173262358423)
+        >>> print(obf_net(input1).asnumpy())
+    """
+    if not isinstance(obf_config, dict):
+        raise TypeError("'obf_config' must be a dict, but got {}.".format(type(obf_config)))
+    file_path = _check_param_type(obf_config, "original_model_path", str, True)
+    if not file_path.endswith(".mindir"):
+        raise ValueError("For 'obfuscate_model', the argument 'file_path'(MindIR file) should end with '.mindir', "
+                         "please input the correct 'file_path'.")
+    if not os.path.exists(file_path):
+        raise ValueError("For 'obfuscate_model', the argument 'file_path'(MindIR file) does not exist, "
+                         "please check whether the 'file_path' is correct.")
+    saved_path = _check_param_type(obf_config, "save_model_path", str, True)
+    model_inputs = _check_param_type(obf_config, "model_inputs", list, True)
+    for item in model_inputs:
+        if not isinstance(item, Tensor):
+            raise TypeError("The item in 'model_inputs' must be Tensor, but got {}.".format(type(item)))
+        if -1 in item.shape:
+            raise ValueError(
+                "Dynamic shape input is not supported now, but got the shape of inputs: {}.".format(item.shape))
+    obf_ratio, customized_funcs, obf_random_seed = _check_obfuscate_params(obf_config)
+    if customized_funcs and obf_random_seed > 0:
+        logger.warning("Although 'customized_func' and 'obf_random_seed' are set, the 'obf_random_seed' mode would be"
+                       " applied, remember to set 'obf_random_seed' when loading obfuscated model.")
+
+    if obf_random_seed == 0:  # apply customized_func mode
+        clean_funcs()
+        for func in customized_funcs:
+            add_opaque_predicate(func.__name__, func)
+        branch_control_input = 0
+    else:  # apply password mode
+        branch_control_input = _generate_branch_control_input(obf_random_seed)
+
+    if 'enc_key' in kwargs.keys():
+        enc_key = Validator.check_isinstance('enc_key', kwargs.get('enc_key'), bytes)
+        enc_mode = "AES-GCM"
+        if 'enc_mode' in kwargs.keys():
+            enc_mode = Validator.check_isinstance('enc_mode', kwargs.get('enc_mode'), str)
+            if enc_mode not in ["AES-GCM", "AES-CBC", "SM4-CBC"]:
+                raise ValueError(
+                    "Only MindIR files that encrypted with 'AES-GCM', 'AES-CBC' or 'SM4-CBC' is supported for"
+                    "obfuscate_model(), but got {}.".format(enc_mode))
+        obf_graph = dynamic_obfuscate_mindir(file_name=file_path, obf_ratio=obf_ratio,
+                                             branch_control_input=branch_control_input, dec_key=enc_key,
+                                             key_len=len(enc_key),
+                                             dec_mode=enc_mode)
+    else:
+        obf_graph = dynamic_obfuscate_mindir(file_name=file_path, obf_ratio=obf_ratio,
+                                             branch_control_input=branch_control_input)
+
+    obf_net = nn.GraphCell(obf_graph)
+    if obf_random_seed != 0:
+        append_y_tensor = Tensor(np.ones((1, 1)).astype(np.int32))
+        model_inputs += [append_y_tensor,]
+    export(obf_net, *model_inputs, file_name=saved_path, file_format="MINDIR", **kwargs)
+
+
 def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=None,
-                    dec_key=None, dec_mode="AES-GCM", specify_prefix=None):
+                    dec_key=None, dec_mode="AES-GCM", specify_prefix=None, choice_func=None):
     """
     Load checkpoint info from a specified file.
 
     Note:
-        1. `specify_prefix` and `filter_prefix` do not affect each other.
-        2. If none of the parameters are loaded from checkpoint file, it will throw ValueError.
+        - `specify_prefix` and `filter_prefix` do not affect each other.
+        - If none of the parameters are loaded from checkpoint file, it will throw ValueError.
+        - `specify_prefix` and `filter_prefix` are in the process of being deprecated,
+          `choice_func` is recommended instead.
+          And using either of those two args will override `choice_func` at the same time.
 
     Args:
         ckpt_file_name (str): Checkpoint file name.
@@ -476,20 +767,25 @@ def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=N
                             into net when parameter name's suffix in checkpoint file is the same as the
                             parameter in the network. When the types are inconsistent perform type conversion
                             on the parameters of the same type, such as float32 to float16. Default: False.
-        filter_prefix (Union[str, list[str], tuple[str]]): Parameters starting with the filter_prefix
-            will not be loaded. Default: None.
+        filter_prefix (Union[str, list[str], tuple[str]]): Deprecated(see `choice_func`). Parameters starting with the
+            filter_prefix will not be loaded. Default: None.
         dec_key (Union[None, bytes]): Byte type key used for decryption. If the value is None, the decryption
                                       is not required. Default: None.
         dec_mode (str): This parameter is valid only when dec_key is not set to None. Specifies the decryption
-                        mode, currently supports 'AES-GCM' and 'AES-CBC'. Default: 'AES-GCM'.
-        specify_prefix (Union[str, list[str], tuple[str]]): Parameters starting with the specify_prefix
-            will be loaded. Default: None.
+                        mode, currently supports 'AES-GCM' and 'AES-CBC' and 'SM4-CBC'. Default: 'AES-GCM'.
+        specify_prefix (Union[str, list[str], tuple[str]]): Deprecated(see `choice_func`). Parameters starting with the
+            specify_prefix will be loaded. Default: None.
+        choice_func (Union[None, function]) : Input value of the function is a Parameter name of type string,
+            and the return value is a bool. If returns True, the Parameter
+            that matches the custom condition will be loaded. If returns False, the Parameter that
+            matches the custom condition will be removed. Default: None.
 
     Returns:
         Dict, key is parameter name, value is a Parameter or string. When the `append_dict` parameter of
-        :func:`mindspore.save_checkpoint` and the `append_info` parameter of :class:`CheckpointConfig` are used to
-        save the checkpoint, `append_dict` and `append_info` are dict types, and their value are string, then the
-        return value obtained by loading checkpoint is string, and in other cases the return value is Parameter.
+        :func:`mindspore.save_checkpoint` and the `append_info` parameter of :class:`mindspore.train.CheckpointConfig`
+        are used to save the checkpoint, `append_dict` and `append_info` are dict types, and their value are string,
+        then the return value obtained by loading checkpoint is string, and in other cases the return value is
+        Parameter.
 
     Raises:
         ValueError: Checkpoint file's format is incorrect.
@@ -500,9 +796,28 @@ def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=N
         >>> import mindspore as ms
         >>>
         >>> ckpt_file_name = "./checkpoint/LeNet5-1_32.ckpt"
-        >>> param_dict = ms.load_checkpoint(ckpt_file_name, filter_prefix="conv1", specify_prefix="conv", )
+        >>> param_dict = ms.load_checkpoint(ckpt_file_name,
+        ...                                 choice_func=lambda x: x.startswith("conv") and not x.startswith("conv1"))
         >>> print(param_dict["conv2.weight"])
         Parameter (name=conv2.weight, shape=(16, 6, 5, 5), dtype=Float32, requires_grad=True)
+        >>> def func(param_name):
+        >>>     whether_load = False
+        >>>     if param_name.startswith("conv"):
+        >>>         whether_load = True
+        >>>     if param_name.startswith("conv1"):
+        >>>         whether_load = False
+        >>>     return whether_load
+        >>> param_dict1 = ms.load_checkpoint(ckpt_file_name, choice_func=func)
+        >>> print(param_dict1["conv2.weight"])
+        Parameter (name=conv2.weight, shape=(16, 6, 5, 5), dtype=Float32, requires_grad=True)
+        >>> def func(param_name):
+        >>>     whether_load = False
+        >>>     if param_name.startswith("conv1"):
+        >>>         whether_load = True
+        >>>     return whether_load
+        >>> param_dict2 = ms.load_checkpoint(ckpt_file_name, choice_func=func)
+        >>> print(param_dict2)
+        {'conv1.weight': Parameter (name=conv1.weight, shape=(6, 1, 5, 5), dtype=Float32, requires_grad=True)}
     """
     ckpt_file_name = _check_ckpt_file_name(ckpt_file_name)
     specify_prefix = _check_prefix(specify_prefix)
@@ -515,15 +830,27 @@ def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=N
     parameter_dict = {}
     try:
         param_data_list = []
+        if specify_prefix:
+            logger.warning("For load_checkpoint, this parameter `specity_prefix` will be deprecated, "
+                           "please use `choice_func` instead.")
+        if filter_prefix:
+            logger.warning("For load_checkpoint, this parameter `filter_prefix` will be deprecated, "
+                           "please use `choice_func` instead.")
         for element_id, element in enumerate(checkpoint_list.value):
             if not _whether_load_param(specify_prefix, filter_prefix, element.tag):
                 continue
+            if specify_prefix is None and filter_prefix is None and \
+                    choice_func is not None and not choice_func(element.tag):
+                continue
+            if element.tensor.ByteSize() == 0:
+                _load_mapparameter(element, parameter_dict)
+                continue
             data = element.tensor.tensor_content
             data_type = element.tensor.tensor_type
             np_type = tensor_to_np_type.get(data_type)
             ms_type = tensor_to_ms_type[data_type]
             if data_type == 'str':
-                str_length = int(len(data)/4)
+                str_length = int(len(data) / 4)
                 np_type = np_type + str(str_length)
             element_data = np.frombuffer(data, np_type)
             param_data_list.append(element_data)
@@ -548,7 +875,7 @@ def load_checkpoint(ckpt_file_name, net=None, strict_load=False, filter_prefix=N
     except BaseException as e:
         logger.critical("Failed to load the checkpoint file '%s'.", ckpt_file_name)
         raise ValueError(e.__str__() + "\nFor 'load_checkpoint', "
-                         "failed to load the checkpoint file {}.".format(ckpt_file_name)) from e
+                                       "failed to load the checkpoint file {}.".format(ckpt_file_name)) from e
 
     if not parameter_dict:
         raise ValueError(f"The loaded parameter dict is empty after filter or specify, please check whether "
@@ -570,7 +897,7 @@ def _check_ckpt_file_name(ckpt_file_name):
         raise ValueError("For 'load_checkpoint', the checkpoint file should end with '.ckpt', please "
                          "input the correct 'ckpt_file_name'.")
 
-    ckpt_file_name = os.path.realpath(ckpt_file_name)
+    ckpt_file_name = os.path.abspath(ckpt_file_name)
     if not os.path.exists(ckpt_file_name):
         raise ValueError("For 'load_checkpoint', the checkpoint file: {} does not exist, please check "
                          "whether the 'ckpt_file_name' is correct.".format(ckpt_file_name))
@@ -616,10 +943,10 @@ def _parse_ckpt_proto(ckpt_file_name, dec_key, dec_mode):
     except BaseException as e:
         if _is_cipher_file(ckpt_file_name):
             err_info = "Failed to read the checkpoint file {}. The file may be encrypted or tempered with, " \
-                     "please pass in the correct 'dec_key' or check the file integrity.".format(ckpt_file_name)
+                       "please pass in the correct 'dec_key' or check the file integrity.".format(ckpt_file_name)
         else:
             err_info = "Failed to read the checkpoint file {}. May not have permission to read it, please check" \
-                     " the correct of the file.".format(ckpt_file_name)
+                       " the correct of the file.".format(ckpt_file_name)
         logger.error(err_info)
         raise ValueError(err_info) from e
     return checkpoint_list
@@ -642,6 +969,20 @@ def _whether_load_param(specify_prefix, filter_prefix, param_name):
     return whether_load
 
 
+def _load_mapparameter(element, parameter_dict):
+    """Load map parameter from ckpt file."""
+    map_array = []
+    for tensor in element.maptensor.tensor:
+        data = tensor.tensor_content
+        data_type = tensor.tensor_type
+        np_type = tensor_to_np_type.get(data_type)
+        element_data = np.frombuffer(data, np_type)
+        dims = tensor.dims
+        param_data = element_data.reshape(list(dims))
+        map_array.append(param_data)
+    parameter_dict[element.tag] = map_array
+
+
 def load_param_into_net(net, parameter_dict, strict_load=False):
     """
     Load parameters into network, return parameter list that are not loaded in the network.
@@ -656,7 +997,8 @@ def load_param_into_net(net, parameter_dict, strict_load=False):
                             on the parameters of the same type, such as float32 to float16. Default: False.
 
     Returns:
-        List, the parameter name which are not loaded into the network.
+        param_not_load (List), the parameter name in model which are not loaded into the network.
+        ckpt_not_load (List), the parameter name in checkpoint file which are not loaded into the network.
 
     Raises:
         TypeError: Argument is not a Cell, or parameter_dict is not a Parameter dictionary.
@@ -667,7 +1009,7 @@ def load_param_into_net(net, parameter_dict, strict_load=False):
         >>> net = Net()
         >>> ckpt_file_name = "./checkpoint/LeNet5-1_32.ckpt"
         >>> param_dict = ms.load_checkpoint(ckpt_file_name, filter_prefix="conv1")
-        >>> param_not_load = ms.load_param_into_net(net, param_dict)
+        >>> param_not_load, _ = ms.load_param_into_net(net, param_dict)
         >>> print(param_not_load)
         ['conv1.weight']
     """
@@ -692,10 +1034,12 @@ def load_param_into_net(net, parameter_dict, strict_load=False):
     logger.info("Execute the process of loading parameters into net.")
     net.init_parameters_data()
     param_not_load = []
+    ckpt_not_load = list(parameter_dict.keys())
     for _, param in net.parameters_and_names():
         if param.name in parameter_dict:
             new_param = copy.deepcopy(parameter_dict[param.name])
             _update_param(param, new_param, strict_load)
+            ckpt_not_load.remove(param.name)
         else:
             param_not_load.append(param.name)
 
@@ -714,7 +1058,7 @@ def load_param_into_net(net, parameter_dict, strict_load=False):
                        "when training and loading checkpoint.".format(len(param_not_load)))
         for param_name in param_not_load:
             logger.warning("{} is not loaded.".format(param_name))
-    return param_not_load
+    return param_not_load, ckpt_not_load
 
 
 def _load_dismatch_prefix_params(net, parameter_dict, param_not_load, strict_load):
@@ -753,7 +1097,7 @@ def _save_graph(network, file_name):
     """
     logger.info("Execute the process of saving graph.")
 
-    file_name = os.path.realpath(file_name)
+    file_name = os.path.abspath(file_name)
     graph_pb = network.get_func_graph_proto()
     if graph_pb:
         with open(file_name, "wb") as f:
@@ -761,7 +1105,7 @@ def _save_graph(network, file_name):
             f.write(graph_pb)
 
 
-def _get_merged_param_data(net, param_name, param_data, integrated_save):
+def _get_merged_param_data(net, parameter_layout_dict, param_name, param_data, integrated_save):
     """
     Gets the merged data(tensor) from tensor slice, by device arrangement and tensor map.
 
@@ -773,7 +1117,7 @@ def _get_merged_param_data(net, param_name, param_data, integrated_save):
     Returns:
         Tensor, the combined tensor which with the whole data value.
     """
-    layout = net.parameter_layout_dict[param_name]
+    layout = parameter_layout_dict[param_name]
     if len(layout) < 6:
         logger.info("The layout dict does not contain the key %s", param_name)
         return param_data
@@ -839,19 +1183,22 @@ def _fill_param_into_net(net, parameter_list):
         else:
             parameter_dict[param_name] = Parameter(Tensor(np_val), name=param_name)
 
-    load_param_into_net(net, parameter_dict)
+    load_param_into_net(net, parameter_dict, strict_load=True)
 
 
-def export(net, *inputs, file_name, file_format='AIR', **kwargs):
+def export(net, *inputs, file_name, file_format, **kwargs):
     """
     Export the MindSpore network into an offline model in the specified format.
 
     Note:
         1. When exporting AIR, ONNX format, the size of a single tensor can not exceed 2GB.
         2. When file_name does not have a suffix, the system will automatically add one according to the file_format.
+        3. Exporting functions decorated with 'jit' to mindir format is supported.
+        4. When exporting a function decorated with 'jit', the function should not involve class properties in
+           calculations.
 
     Args:
-        net (Cell): MindSpore network.
+        net (Union[Cell, function]): MindSpore network.
         inputs (Union[Tensor, Dataset, List, Tuple, Number, Bool]): It represents the inputs
              of the `net`, if the network has multiple inputs, set them together. While its type is Dataset,
              it represents the preprocess behavior of the `net`, data preprocess operations will be serialized.
@@ -859,7 +1206,6 @@ def export(net, *inputs, file_name, file_format='AIR', **kwargs):
              the batch size of 'net' input. Only supports parse "image" column from dataset currently.
         file_name (str): File name of the model to be exported.
         file_format (str): MindSpore currently supports 'AIR', 'ONNX' and 'MINDIR' format for exported model.
-            Default: 'AIR'.
 
             - AIR: Ascend Intermediate Representation. An intermediate representation format of Ascend model.
             - ONNX: Open Neural Network eXchange. An open format built to represent machine learning models.
@@ -868,20 +1214,36 @@ def export(net, *inputs, file_name, file_format='AIR', **kwargs):
 
         kwargs (dict): Configuration options dictionary.
 
-            - quant_mode (str): If the network is a quantization aware training network, the quant_mode should
-              be set to "QUANT", else the quant_mode should be set to "NONQUANT".
-            - mean (float): The mean of input data after preprocessing, used for quantizing the first layer of network.
-              Default: 127.5.
-            - std_dev (float): The variance of input data after preprocessing,
-              used for quantizing the first layer of the network. Default: 127.5.
             - enc_key (byte): Byte-type key used for encryption. The valid length is 16, 24, or 32.
             - enc_mode (Union[str, function]): Specifies the encryption mode, to take effect when enc_key is set.
 
               - For 'AIR' and 'ONNX' models, only customized encryption is supported.
-              - For 'MINDIR', all options are supported. Option: 'AES-GCM', 'AES-CBC' or Customized encryption.
+              - For 'MINDIR', all options are supported. Option: 'AES-GCM', 'AES-CBC', 'SM4-CBC'
+                or Customized encryption.
                 Default: 'AES-GCM'.
               - For details of using the customized encryption, please check the `tutorial
-                <https://mindspore.cn/mindarmour/docs/en/r1.10/model_encrypt_protection.html>`_.
+                <https://mindspore.cn/mindarmour/docs/en/r2.0/model_encrypt_protection.html>`_.
+
+            - dataset (Dataset): Specifies the preprocessing method of the dataset, which is used to import the
+              preprocessing of the dataset into MindIR.
+
+            - obf_config (dict): obfuscation config.
+
+              - type (str): The type of obfuscation, only 'dynamic' is supported until now.
+              - obf_ratio (float, str): The ratio of nodes in original model that would be obfuscated. `obf_ratio`
+                should be in range of (0, 1] or in ["small", "medium", "large"].
+              - customized_func (function): A python function used for customized function mode, which used for control
+                the switch branch of obfuscation structure. The outputs of customized_func should be boolean. This
+                function needs to ensure that its result is constant for any input. Users can refer to opaque
+                predicates. If customized_func is set, then it should be passed to `load()` interface when loading
+                obfuscated model.
+              - obf_random_seed (int): The random seed used for determine the distribution of confusion branches and the
+                weight confusion coefficient, which should be in (0, 9223372036854775807]. If `obf_random_seed` is set,
+                then it should be passed to :class:`nn.GraphCell()` interface when loading obfuscated model. It should
+                be noted that at least one of `customized_func` or `obf_random_seed` should be set, and the latter mode
+                would be applied if both of them are set.
+
+            - incremental (bool): export MindIR incrementally.
 
     Examples:
         >>> import mindspore as ms
@@ -892,7 +1254,12 @@ def export(net, *inputs, file_name, file_format='AIR', **kwargs):
         >>> input_tensor = Tensor(np.ones([1, 1, 32, 32]).astype(np.float32))
         >>> ms.export(net, input_tensor, file_name='lenet', file_format='MINDIR')
     """
+    supported_formats = ['AIR', 'ONNX', 'MINDIR']
+    if file_format not in supported_formats:
+        raise ValueError(f"For 'export', 'file_format' must be one of {supported_formats}, but got {file_format}.")
+    Validator.check_file_name_by_regular(file_name)
     logger.info("exporting model file:%s format:%s.", file_name, file_format)
+
     if check_input_dataset(*inputs, dataset_type=mindspore.dataset.Dataset):
         if len(inputs) != 1:
             raise RuntimeError(f"You can only serialize one dataset into MindIR, got " + str(len(inputs)) + " datasets")
@@ -910,15 +1277,10 @@ def export(net, *inputs, file_name, file_format='AIR', **kwargs):
                                + str(columns))
         inputs = tuple(inputs_col)
 
-    Validator.check_file_name_by_regular(file_name)
-    file_name = os.path.realpath(file_name)
-    net = _quant_export(net, *inputs, file_format=file_format, **kwargs)
+    file_name = os.path.abspath(file_name)
     if 'enc_key' in kwargs.keys():
-        enc_key, enc_mode = _check_key_mode_type(file_format, **kwargs)
-        dataset = kwargs.get('dataset')
-        _export(net, file_name, file_format, *inputs, enc_key=enc_key, enc_mode=enc_mode, dataset=dataset)
-    else:
-        _export(net, file_name, file_format, *inputs, **kwargs)
+        kwargs['enc_key'], kwargs['enc_mode'] = _check_key_mode_type(file_format, **kwargs)
+    _export(net, file_name, file_format, *inputs, **kwargs)
 
 
 def _export(net, file_name, file_format, *inputs, **kwargs):
@@ -926,19 +1288,8 @@ def _export(net, file_name, file_format, *inputs, **kwargs):
     It is an internal conversion function. Export the MindSpore prediction model to a file in the specified format.
     """
     logger.info("exporting model file:%s format:%s.", file_name, file_format)
-
-    if file_format == 'GEIR':
-        logger.warning(f"For 'export', format 'GEIR' is deprecated, "
-                       f"it would be removed in future release, use 'AIR' instead.")
-        file_format = 'AIR'
-
-    supported_formats = ['AIR', 'ONNX', 'MINDIR']
-    if file_format not in supported_formats:
-        raise ValueError(f"For 'export', 'file_format' must be one of {supported_formats}, but got {file_format}.")
-    # When dumping ONNX file, switch network mode to infer when it is training(NOTE: ONNX only designed for prediction)
-    is_dump_onnx_in_training = net.training and file_format == 'ONNX'
-    if is_dump_onnx_in_training:
-        net.set_train(mode=False)
+    if "obf_config" in kwargs and file_format != "MINDIR":
+        raise ValueError(f"Dynamic obfuscation only support for MindIR format, but got {file_format} format.")
 
     if file_format == 'AIR':
         _save_air(net, file_name, *inputs, **kwargs)
@@ -947,9 +1298,6 @@ def _export(net, file_name, file_format, *inputs, **kwargs):
     elif file_format == 'MINDIR':
         _save_mindir(net, file_name, *inputs, **kwargs)
 
-    if is_dump_onnx_in_training:
-        net.set_train(mode=True)
-
 
 def _check_key_mode_type(file_format, **kwargs):
     """check enc_key and enc_mode are valid"""
@@ -966,9 +1314,9 @@ def _check_key_mode_type(file_format, **kwargs):
     if file_format in ('AIR', 'ONNX'):
         raise ValueError(f"AIR/ONNX only support customized encryption, but got {enc_mode}.")
 
-    if enc_mode in ('AES-CBC', 'AES-GCM'):
+    if enc_mode in ('AES-CBC', 'AES-GCM', 'SM4-CBC'):
         return enc_key, enc_mode
-    raise ValueError(f"MindIR only support AES-GCM/AES-CBC encryption, but got {enc_mode}")
+    raise ValueError(f"MindIR only support AES-GCM/AES-CBC/SM4-CBC encryption, but got {enc_mode}")
 
 
 def _save_air(net, file_name, *inputs, **kwargs):
@@ -980,7 +1328,7 @@ def _save_air(net, file_name, *inputs, **kwargs):
     if os.path.exists(file_name):
         os.chmod(file_name, stat.S_IWUSR)
     if "/" in file_name:
-        real_path = os.path.realpath(file_name[:file_name.rfind("/")])
+        real_path = os.path.abspath(file_name[:file_name.rfind("/")])
         os.makedirs(real_path, exist_ok=True)
     if 'enc_key' in kwargs.keys() and 'enc_mode' in kwargs.keys():
         _executor.export(file_name, graph_id, enc_key=kwargs.get('enc_key'), encrypt_func=kwargs.get('enc_mode'))
@@ -991,6 +1339,12 @@ def _save_air(net, file_name, *inputs, **kwargs):
 
 def _save_onnx(net, file_name, *inputs, **kwargs):
     """Save ONNX format file."""
+    # When dumping ONNX file, switch network mode to infer when it is training(NOTE: ONNX only designed for prediction)
+    if not isinstance(net, nn.Cell):
+        raise ValueError(f"Export ONNX format model only support nn.Cell object, but got {type(net)}.")
+    _check_dynamic_input(inputs)
+    cell_mode = net.training
+    net.set_train(mode=False)
     total_size = _calculation_net_size(net)
     if total_size > PROTO_LIMIT_SIZE:
         raise RuntimeError('Export onnx model failed. Network size is: {}G, it exceeded the protobuf: {}G limit.'
@@ -1008,6 +1362,13 @@ def _save_onnx(net, file_name, *inputs, **kwargs):
     with open(file_name, 'wb') as f:
         f.write(onnx_stream)
         os.chmod(file_name, stat.S_IRUSR)
+    net.set_train(mode=cell_mode)
+
+
+def _check_dynamic_input(inputs):
+    for ele in inputs:
+        if isinstance(ele, Tensor) and -1 in ele.shape:
+            raise ValueError(f"Export ONNX format model not support dynamic shape mode.")
 
 
 def _generate_front_info_for_param_data_file(is_encrypt, kwargs):
@@ -1057,10 +1418,24 @@ def _get_data_file(is_encrypt, kwargs, data_file_name):
     return f, parameter_size, offset
 
 
-def _spilt_save(net_dict, model, file_name, is_encrypt, **kwargs):
+def _encrypt_data(is_encrypt, write_data, kwargs):
+    """Encrypt parameter data."""
+    if is_encrypt():
+        if callable(kwargs.get('enc_mode')):
+            enc_func = kwargs.get('enc_mode')
+            write_data = enc_func(write_data, kwargs.get('enc_key'))
+        else:
+            write_data = _encrypt(write_data, len(write_data), kwargs.get('enc_key'),
+                                  len(kwargs.get('enc_key')), kwargs.get('enc_mode'))
+    return write_data
+
+
+def _split_save(net_dict, model, file_name, is_encrypt, **kwargs):
     """The function to save parameter data."""
     logger.warning("Parameters in the net capacity exceeds 1G, save MindIR model and parameters separately.")
     # save parameter
+    if model.graph.map_parameter:
+        raise ValueError("MapParameter not support save in split MindIR file now.")
     file_prefix = file_name.split("/")[-1]
     if file_prefix.endswith(".mindir"):
         file_prefix = file_prefix[:-7]
@@ -1095,13 +1470,7 @@ def _spilt_save(net_dict, model, file_name, is_encrypt, **kwargs):
             param_proto.external_data.offset = offset
             write_data = raw_data + bytes(append_size)
             offset += (data_length + append_size)
-            if is_encrypt():
-                if callable(kwargs.get('enc_mode')):
-                    enc_func = kwargs.get('enc_mode')
-                    write_data = enc_func(write_data, kwargs.get('enc_key'))
-                else:
-                    write_data = _encrypt(write_data, len(write_data), kwargs.get('enc_key'),
-                                          len(kwargs.get('enc_key')), kwargs.get('enc_mode'))
+            write_data = _encrypt_data(is_encrypt, write_data, kwargs)
             f.write(write_data)
 
         graph_file_name = os.path.join(dirname, file_prefix + "_graph.mindir")
@@ -1124,18 +1493,74 @@ def _spilt_save(net_dict, model, file_name, is_encrypt, **kwargs):
         os.chmod(data_file_name, stat.S_IRUSR)
 
 
-def _save_mindir(net, file_name, *inputs, **kwargs):
-    """Save MindIR format file."""
-    model = mindir_model()
+def _msfunc_info(net, *inputs):
+    """Get mindir stream and parameter dict of ms_function"""
+    # pylint: disable=protected-access
+    net_dict = OrderedDict()
+    _ms_func_executor = _MindsporeFunctionExecutor(net, time.time() * 1e9)
+    graph_id = _ms_func_executor.compile(net.__name__, *inputs)
+    mindir_stream = _executor._get_func_graph_proto(net, graph_id, 'mind_ir')
+    params = _ms_func_executor._graph_executor.get_params(graph_id)
+    for name, value in params.items():
+        net_dict[name] = Parameter(value, name=name)
+    return mindir_stream, net_dict
 
-    phase_name = "predict" if net._auto_parallel_mode else "export.mindir"
 
-    graph_id, _ = _executor.compile(net, *inputs, phase=phase_name,
-                                    do_convert=False, auto_parallel_mode=net._auto_parallel_mode)
+def _cell_info(net, incremental, *inputs):
+    """Get mindir stream and net dict of cell"""
+    phase_name = "predict" if _is_in_auto_parallel_mode() else "export.mindir"
+    graph_id, _ = _executor.compile(net, *inputs, phase=phase_name, do_convert=False)
     # pylint: disable=protected-access
-    mindir_stream = _executor._get_func_graph_proto(net, graph_id, 'mind_ir')
+    mindir_stream = _executor._get_func_graph_proto(net, graph_id, 'mind_ir', incremental=incremental)
+    # clean obfuscation config to prevent the next call
+    _executor.obfuscate_config = None
 
     net_dict = net.parameters_dict()
+    return mindir_stream, net_dict
+
+
+def _set_obfuscate_config(**kwargs):
+    """Set obfuscation config for executor."""
+    logger.warning("Obfuscate model.")
+    if 'enc_mode' in kwargs.keys():
+        enc_mode = Validator.check_isinstance('enc_mode', kwargs.get('enc_mode'), str)
+        if enc_mode not in ["AES-GCM", "AES-CBC", "SM4-CBC"]:
+            raise ValueError(
+                "Only MindIR files that encrypted with 'AES-GCM', 'AES-CBC' or 'SM4-CBC' is supported for"
+                "obfuscation, but got {}.".format(enc_mode))
+    obf_ratio, customized_funcs, obf_random_seed = _check_obfuscate_params(kwargs.get('obf_config'))
+    if customized_funcs and obf_random_seed > 0:
+        logger.warning("Although 'customized_func' and 'obf_random_seed' are set, the 'obf_random_seed' mode would be"
+                       " applied, remember to set 'obf_random_seed' when loading obfuscated model.")
+
+    if obf_random_seed == 0:  # apply customized_func mode
+        device_target = context.get_context('device_target')
+        if device_target in ["GPU", "Ascend"]:
+            raise ValueError(
+                "Customized func mode only support 'device_target'='CPU, but got {}.".format(device_target))
+        clean_funcs()
+        for func in customized_funcs:
+            add_opaque_predicate(func.__name__, func)
+    _executor.obfuscate_config = {'obf_ratio': obf_ratio, 'obf_random_seed': obf_random_seed}
+
+
+def _save_mindir(net, file_name, *inputs, **kwargs):
+    """Save MindIR format file."""
+    # set obfuscate configs
+    if 'obf_config' in kwargs.keys():
+        _set_obfuscate_config(**kwargs)
+        for item in inputs:
+            if -1 in item.shape:
+                raise ValueError(
+                    "Dynamic shape input is not supported now, but got the shape of inputs: {}.".format(item.shape))
+
+    incremental = kwargs.get('incremental', False)
+
+    model = mindir_model()
+    if not isinstance(net, nn.Cell):
+        mindir_stream, net_dict = _msfunc_info(net, *inputs)
+    else:
+        mindir_stream, net_dict = _cell_info(net, incremental, *inputs)
     model.ParseFromString(mindir_stream)
 
     if kwargs.get('dataset'):
@@ -1148,7 +1573,7 @@ def _save_mindir(net, file_name, *inputs, **kwargs):
     if save_together:
         _save_mindir_together(net_dict, model, file_name, is_encrypt, **kwargs)
     else:
-        _spilt_save(net_dict, model, file_name, is_encrypt, **kwargs)
+        _split_save(net_dict, model, file_name, is_encrypt, **kwargs)
 
 
 def _save_mindir_together(net_dict, model, file_name, is_encrypt, **kwargs):
@@ -1159,9 +1584,20 @@ def _save_mindir_together(net_dict, model, file_name, is_encrypt, **kwargs):
             param_data = net_dict[param_name].data.asnumpy().tobytes()
             param_proto.raw_data = param_data
         else:
-            logger.critical("The parameter '%s' in the graph should also be defined in the network.", param_name)
-            raise ValueError("The parameter '{}' in the graph should also be defined in the "
-                             "network.".format(param_name))
+            raise ValueError("The parameter '{}' is not belongs to any cell,"
+                             "the data of parameter cannot be exported.".format(param_proto.name))
+    incremental = kwargs.get('incremental', False)
+    for map_param_proto in model.graph.map_parameter:
+        map_param_name = map_param_proto.name[map_param_proto.name.find(":") + 1:]
+        if map_param_name in net_dict.keys():
+            map_parameter = net_dict[map_param_name]
+            key_nparr, value_nparr, status_nparr = map_parameter.export_data(incremental)
+            map_param_proto.key_tensor.raw_data = key_nparr.tobytes()
+            map_param_proto.value_tensor.raw_data = value_nparr.tobytes()
+            map_param_proto.status_tensor.raw_data = status_nparr.tobytes()
+        else:
+            raise ValueError("The map_parameter '{}' is not belongs to any cell,"
+                             "the data of parameter cannot be exported.".format(map_param_proto.name))
     if not file_name.endswith('.mindir'):
         file_name += ".mindir"
     current_path = os.path.abspath(file_name)
@@ -1191,9 +1627,8 @@ def _save_together(net_dict, model):
         if name in net_dict.keys():
             data_total += sys.getsizeof(net_dict[name].data.asnumpy().tobytes()) / 1024
         else:
-
-            raise ValueError("The parameter '{}' in the graph should also be defined in the network."
-                             .format(param_proto.name))
+            raise ValueError("The parameter '{}' is not belongs to any cell,"
+                             "the data of parameter cannot be exported.".format(param_proto.name))
         if data_total > TOTAL_SAVE:
             return False
     return True
@@ -1214,67 +1649,11 @@ def _save_dataset_to_mindir(model, dataset):
             model.preprocessor.op.add()
             model.preprocessor.op[-1].input_columns = json.dumps(op['input_columns'])
             model.preprocessor.op[-1].output_columns = json.dumps(op['output_columns'])
-            model.preprocessor.op[-1].project_columns = json.dumps(op['project_columns'])
             model.preprocessor.op[-1].op_type = json.dumps(op['op_type'])
             model.preprocessor.op[-1].operations = json.dumps(op['operations'])
             model.preprocessor.op[-1].offload = op['offload'] if 'offload' in op.keys() else False
 
 
-def quant_mode_manage(func):
-    """Inherit the quant_mode in old version."""
-    @functools.wraps(func)
-    def warpper(network, *inputs, file_format, **kwargs):
-        if 'quant_mode' not in kwargs:
-            return network
-        quant_mode = kwargs.get('quant_mode')
-        if not isinstance(quant_mode, str):
-            raise TypeError("For 'export', the type of 'quant_mode' should be string, "
-                            "but got {}.".format(type(quant_mode)))
-        if quant_mode in ('AUTO', 'MANUAL'):
-            kwargs['quant_mode'] = 'QUANT'
-        return func(network, *inputs, file_format=file_format, **kwargs)
-
-    return warpper
-
-
-@quant_mode_manage
-def _quant_export(network, *inputs, file_format, **kwargs):
-    """Exports MindSpore quantization predict model to deploy with AIR and MINDIR."""
-    supported_device = ["Ascend", "GPU"]
-    supported_formats = ['AIR', 'MINDIR']
-    quant_mode_formats = ['QUANT', 'NONQUANT']
-
-    quant_mode = kwargs['quant_mode']
-    if quant_mode not in quant_mode_formats:
-        raise KeyError(f"For 'export', the argument 'quant_mode' must be one of {quant_mode_formats}, "
-                       f"but got {quant_mode}.")
-    if quant_mode == 'NONQUANT':
-        return network
-    quant_net = copy.deepcopy(network)
-    quant_net._create_time = int(time.time() * 1e9)
-
-    mean = 127.5 if kwargs.get('mean', None) is None else kwargs.get('mean')
-    std_dev = 127.5 if kwargs.get('std_dev', None) is None else kwargs.get('std_dev')
-    mean = Validator.check_value_type("mean", mean, (int, float))
-    std_dev = Validator.check_value_type("std_dev", std_dev, (int, float))
-
-    if context.get_context('device_target') not in supported_device:
-        raise KeyError(f"For 'export', quant export only support {supported_device} device target now, "
-                       f"but got {context.get_context('device_target')}")
-
-    if file_format not in supported_formats:
-        raise ValueError(f"For 'export', quant export only support 'file_format' {supported_formats}, "
-                         f"but got {file_format}.")
-
-    quant_net.set_train(False)
-    if file_format == "MINDIR":
-        exporter = quant_export.ExportToQuantInferNetwork(quant_net, mean, std_dev, *inputs, is_mindir=True)
-    else:
-        exporter = quant_export.ExportToQuantInferNetwork(quant_net, mean, std_dev, *inputs)
-    deploy_net = exporter.run()
-    return deploy_net
-
-
 def parse_print(print_file_name):
     """
     Parse data file generated by mindspore.ops.Print.
@@ -1316,7 +1695,7 @@ def parse_print(print_file_name):
         [[ 1.00000000e+00,  2.00000000e+00,  3.00000000e+00,  4.00000000e+00],
         [ 5.00000000e+00,  6.00000000e+00,  7.00000000e+00,  8.00000000e+00]])]
     """
-    print_file_path = os.path.realpath(print_file_name)
+    print_file_path = os.path.abspath(print_file_name)
 
     if os.path.getsize(print_file_path) == 0:
         raise ValueError("For 'parse_print', the print file may be empty, please make sure enter the correct "
@@ -1490,7 +1869,8 @@ def build_searched_strategy(strategy_filename):
     """
     Build strategy of every parameter in network. Used in the case of distributed inference.
     For details of it, please check:
-    `<https://www.mindspore.cn/tutorials/experts/en/r1.10/parallel/save_load.html>`_.
+    `Saving and Loading Models in Hybrid Parallel Mode
+    <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/save_load.html>`_.
 
     Args:
         strategy_filename (str): Name of strategy file.
@@ -1512,7 +1892,7 @@ def merge_sliced_parameter(sliced_parameters, strategy=None):
     """
     Merge parameter slices into one parameter. Used in the case of distributed inference.
     For details of it, please check:
-    `<https://www.mindspore.cn/tutorials/experts/en/r1.10/parallel/save_load.html>`_.
+    `<https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/save_load.html>`_.
 
     Args:
         sliced_parameters (list[Parameter]): Parameter slices in order of rank id.
@@ -1608,7 +1988,7 @@ def load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=
     Load checkpoint into net for distributed predication. Used in the case of distributed inference.
     For details of distributed inference, please check:
     `Distributed Inference
-    <https://www.mindspore.cn/tutorials/experts/en/r1.10/parallel/distributed_inference.html>`_ .
+    <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/distributed_inference.html>`_ .
 
     Args:
         network (Cell): Network for distributed predication.
@@ -1627,7 +2007,7 @@ def load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=
         dec_key (Union[None, bytes]): Byte type key used for decryption. If the value is None, the decryption
                                       is not required. Default: None.
         dec_mode (str): This parameter is valid only when dec_key is not set to None. Specifies the decryption
-                        mode, currently supports 'AES-GCM' and 'AES-CBC'. Default: 'AES-GCM'.
+                        mode, currently supports 'AES-GCM', 'AES-CBC' and 'SM4-CBC'. Default: 'AES-GCM'.
 
     Raises:
         TypeError: The type of inputs do not match the requirements.
@@ -1720,8 +2100,8 @@ def load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=
                 logger.critical("Failed to load opt shard slice in load distributed checkpoint for {}. Data shape is {}"
                                 " and group is {}".format(param.name, split_param.data.shape, opt_shard_group))
                 raise RuntimeError(e.__str__() + f"\nFor 'load_distributed_checkpoint', failed to load opt shard slice"
-                                   f" in load distributed checkpoint for {param.name}. Data shape is "
-                                   f"{split_param.data.shape} and group is {opt_shard_group}.") from e
+                                                 f" in load distributed checkpoint for {param.name}. Data shape is "
+                                                 f"{split_param.data.shape} and group is {opt_shard_group}.") from e
             split_param = Parameter(Tensor(data_slice), param.name,
                                     split_param.requires_grad, split_param.layerwise_parallel)
         param_dict[param.name] = split_param
@@ -1843,7 +2223,7 @@ def _get_mindir_inputs(file_name):
         >>> input_tensor = get_mindir_inputs("lenet.mindir")
     """
     Validator.check_file_name_by_regular(file_name)
-    file_name = os.path.realpath(file_name)
+    file_name = os.path.abspath(file_name)
     model = read_proto(file_name)
     input_tensor = []
 
@@ -1874,8 +2254,8 @@ def convert_model(mindir_file, convert_file, file_format):
     """
     Convert mindir model to other format model. Current version only support convert to "ONNX" format.
 
-    Note:
-        This is an experimental function that is subject to change or deletion.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         mindir_file (str): MindIR file name.