mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/train/serialization.py

@@ -25,7 +25,6 @@ import stat
 import threading
 from threading import Thread, Lock
 from collections import defaultdict, OrderedDict
-from functools import wraps
 from io import BytesIO
 
 import math
@@ -41,17 +40,19 @@ 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
@@ -216,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)
@@ -253,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):
@@ -262,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))
@@ -321,7 +364,23 @@ 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
@@ -345,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')
@@ -375,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:
@@ -414,11 +507,11 @@ def load(file_name, **kwargs):
 
               - 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/r2.0.0-alpha/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.0-alpha/api_python/mindspore/mindspore.obfuscate_model.html>` .
+              <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`.
@@ -432,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))
@@ -453,7 +548,7 @@ 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)
@@ -488,14 +583,15 @@ def _check_param_type(param_config, key, target_type, requested):
     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_password':
+        if key == 'obf_random_seed':
             if param_config[key] > INT_64_MAX or param_config[key] <= 0:
                 raise ValueError(
-                    "'obf_password' must be in (0, INT_64_MAX({})], but got {}.".format(INT_64_MAX, param_config[key]))
+                    "'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_password":
+    if key == "obf_random_seed":
         return 0
     return None
 
@@ -517,10 +613,10 @@ def _check_customized_func(customized_func):
 
 
 def _check_obfuscate_params(obf_config):
-    """check obfuscation parameters, including obf_password, obf_ratio, customized_func"""
-    if 'obf_password' not in obf_config.keys() and 'customized_func' not in obf_config.keys():
+    """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_password' or 'customized_func' must be set in obf_config, but got None of them.")
+            "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))
@@ -535,9 +631,13 @@ def _check_obfuscate_params(obf_config):
         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_password = _check_param_type(obf_config, "obf_password", int, False)
-    return obf_ratio, customized_funcs, obf_password
+    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):
@@ -553,18 +653,19 @@ def obfuscate_model(obf_config, **kwargs):
               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 `export()`.
+              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 `load()` interface when loading
-              obfuscated model.
-            - obf_password (int): A password used for password mode, which should be in (0, 9223372036854775807]. If
-              obf_password is set, then it should be passed to `nn.GraphCell()` interface when loading obfuscated
-              model. It should be noted that at least one of 'customized_func' or 'obf_password' should be set, and
-              'obf_password' mode would be applied if both of them are set.
+              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.
 
@@ -573,24 +674,24 @@ def obfuscate_model(obf_config, **kwargs):
               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_password are not provided in obf_config.
-        ValueError: If both obf_password is not in (0, 9223372036854775807].
-        ValueError: If file_path is not exist or file_path is not end with '.mindir'.
+        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_password': 173262358423}
+        ...          '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_password=173262358423)
+        >>> obf_net = nn.GraphCell(obf_func, obf_random_seed=173262358423)
         >>> print(obf_net(input1).asnumpy())
     """
     if not isinstance(obf_config, dict):
@@ -610,22 +711,18 @@ def obfuscate_model(obf_config, **kwargs):
         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_password = _check_obfuscate_params(obf_config)
-    if customized_funcs and obf_password > 0:
-        logger.warning("Although 'customized_func' and 'obf_password' are set, the 'obf_password' mode would be"
-                       " applied, remember to set 'obf_password' when loading obfuscated model.")
+    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_password == 0:  # apply customized_func mode
+    if obf_random_seed == 0:  # apply customized_func mode
         clean_funcs()
         for func in customized_funcs:
             add_opaque_predicate(func.__name__, func)
-        append_password = 0
-    else:
-        seed_max = 2 ** 32 - 1
-        int_max = 2 ** 31 - 1
-        np.random.seed(obf_password % seed_max)
-        append_password = np.random.randint(int_max)
-        obf_password %= int_max
+        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)
@@ -636,29 +733,32 @@ def obfuscate_model(obf_config, **kwargs):
                 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, obf_password=obf_password,
-                                             append_password=append_password, dec_key=enc_key, key_len=len(enc_key),
+        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, obf_password=obf_password,
-                                             append_password=append_password)
+        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_password != 0:
-        y_tensor = Tensor(np.ones((1, 1)).astype(np.int32))
+    if obf_random_seed != 0:
         append_y_tensor = Tensor(np.ones((1, 1)).astype(np.int32))
-        model_inputs += [y_tensor, append_y_tensor]
+        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.
@@ -667,14 +767,18 @@ 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' and 'SM4-CBC'. Default: 'AES-GCM'.
-        specify_prefix (Union[str, list[str], tuple[str]]): Parameters starting with the specify_prefix
-            will be loaded. Default: None.
+        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
@@ -692,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)
@@ -707,9 +830,21 @@ 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)
@@ -762,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))
@@ -834,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.
@@ -848,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.
@@ -859,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']
     """
@@ -884,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)
 
@@ -906,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):
@@ -945,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:
@@ -1031,7 +1183,7 @@ 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, **kwargs):
@@ -1062,12 +1214,6 @@ def export(net, *inputs, file_name, file_format, **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.
 
@@ -1076,7 +1222,7 @@ def export(net, *inputs, file_name, file_format, **kwargs):
                 or Customized encryption.
                 Default: 'AES-GCM'.
               - For details of using the customized encryption, please check the `tutorial
-                <https://mindspore.cn/mindarmour/docs/en/r2.0.0-alpha/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.
@@ -1091,10 +1237,14 @@ def export(net, *inputs, file_name, file_format, **kwargs):
                 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_password (int): A password used for password mode, which should be in (0, 9223372036854775807]. If
-                obf_password is set, then it should be passed to `nn.GraphCell()` interface when loading obfuscated
-                model. It should be noted that at least one of 'customized_func' or 'obf_password' should be set, and
-                'obf_password' mode would be applied if both of them are set.
+              - 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
         >>> import numpy as np
@@ -1127,8 +1277,7 @@ def export(net, *inputs, file_name, file_format, **kwargs):
                                + str(columns))
         inputs = tuple(inputs_col)
 
-    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():
         kwargs['enc_key'], kwargs['enc_mode'] = _check_key_mode_type(file_format, **kwargs)
     _export(net, file_name, file_format, *inputs, **kwargs)
@@ -1139,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'
-
-    # When dumping ONNX file, switch network mode to infer when it is training(NOTE: ONNX only designed for prediction)
-    is_dump_onnx_in_training = False
-    if hasattr(net, 'training'):
-        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)
@@ -1160,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"""
@@ -1193,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'))
@@ -1204,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.'
@@ -1221,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):
@@ -1270,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]
@@ -1308,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")
@@ -1342,7 +1498,7 @@ def _msfunc_info(net, *inputs):
     # pylint: disable=protected-access
     net_dict = OrderedDict()
     _ms_func_executor = _MindsporeFunctionExecutor(net, time.time() * 1e9)
-    graph_id = _ms_func_executor.compile(args_list=inputs, method_name=net.__name__)
+    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():
@@ -1350,12 +1506,12 @@ def _msfunc_info(net, *inputs):
     return mindir_stream, net_dict
 
 
-def _cell_info(net, *inputs):
+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
 
@@ -1372,16 +1528,20 @@ def _set_obfuscate_config(**kwargs):
             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_password = _check_obfuscate_params(kwargs.get('obf_config'))
-    if customized_funcs and obf_password > 0:
-        logger.warning("Although 'customized_func' and 'obf_password' are set, the 'obf_password' mode would be"
-                       " applied, remember to set 'obf_password' when loading obfuscated model.")
-
-    if obf_password == 0:  # apply customized_func 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_password': obf_password}
+    _executor.obfuscate_config = {'obf_ratio': obf_ratio, 'obf_random_seed': obf_random_seed}
 
 
 def _save_mindir(net, file_name, *inputs, **kwargs):
@@ -1394,11 +1554,13 @@ def _save_mindir(net, file_name, *inputs, **kwargs):
                 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, *inputs)
+        mindir_stream, net_dict = _cell_info(net, incremental, *inputs)
     model.ParseFromString(mindir_stream)
 
     if kwargs.get('dataset'):
@@ -1411,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):
@@ -1422,19 +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.warning("The parameter '{}' is not belongs to any cell,the data of parameter cannot be exported."
-                           .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))
+    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()
+            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:
-            logger.warning("The map_parameter '{}' is not belongs to any cell,the data of parameter cannot be exported."
-                           .format(map_param_proto.name))
+            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)
@@ -1464,8 +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:
-            logger.info("The parameter '{}' is not belongs to any cell,the data of parameter cannot be exported."
-                        .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
@@ -1491,62 +1654,6 @@ def _save_dataset_to_mindir(model, dataset):
             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."""
-
-    @wraps(func)
-    def wrapper(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 wrapper
-
-
-@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.
@@ -1588,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 "
@@ -1763,7 +1870,7 @@ 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:
     `Saving and Loading Models in Hybrid Parallel Mode
-    <https://www.mindspore.cn/tutorials/experts/en/r2.0.0-alpha/parallel/save_load.html>`_.
+    <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/save_load.html>`_.
 
     Args:
         strategy_filename (str): Name of strategy file.
@@ -1785,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/r2.0.0-alpha/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.
@@ -1880,8 +1987,8 @@ 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/r2.0.0-alpha/parallel/
-    distributed_inference.html>`_ .
+    `Distributed Inference
+    <https://www.mindspore.cn/tutorials/experts/en/r2.0/parallel/distributed_inference.html>`_ .
 
     Args:
         network (Cell): Network for distributed predication.
@@ -2116,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 = []
 
@@ -2147,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.