mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/boost/boost_cell_wrapper.py

@@ -113,7 +113,8 @@ class BoostTrainOneStepCell(TrainOneStepCell):
     Args:
         network (Cell): The training network. The network only supports single output.
         optimizer (Union[Cell]): Optimizer for updating the weights.
-        sens (numbers.Number): The scaling number to be filled as the input of backpropagation. Default value is 1.0.
+        sens (numbers.Number): The scaling number to be filled as the input of backpropagation.
+            Default: ``None`` , which is ``1.0`` .
 
     Inputs:
         - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
@@ -133,7 +134,10 @@ class BoostTrainOneStepCell(TrainOneStepCell):
 
     Examples:
         >>> from mindspore import boost
-        >>> net = Net()
+        >>> from mindspore import nn
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
         >>> #1) Using the WithLossCell existing provide
@@ -141,7 +145,7 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         >>> train_net = boost.BoostTrainOneStepCell(loss_net, optim)
         >>>
         >>> #2) Using user-defined WithLossCell
-        >>> class MyWithLossCell(Cell):
+        >>> class MyWithLossCell(nn.Cell):
         ...    def __init__(self, backbone, loss_fn):
         ...        super(MyWithLossCell, self).__init__(auto_prefix=False)
         ...        self._backbone = backbone
@@ -159,7 +163,7 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         >>> train_net = boost.BoostTrainOneStepCell(loss_net, optim)
     """
 
-    def __init__(self, network, optimizer, sens=1.0):
+    def __init__(self, network, optimizer, sens=None):
         super(BoostTrainOneStepCell, self).__init__(network, optimizer, sens)
         self.hyper_map = C.HyperMap()
         self.freeze = isinstance(optimizer, FreezeOpt)
@@ -208,6 +212,8 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         if self.freeze:
             loss = self.gradient_freeze_process(*inputs)
         else:
+            if not self.sense_flag:
+                return self._no_sens_impl(*inputs)
             loss = self.network(*inputs)
             sens = F.fill(loss.dtype, loss.shape, self.sens)
             grads = self.grad(self.network, self.weights)(*inputs, sens)
@@ -333,6 +339,22 @@ class BoostTrainOneStepCell(TrainOneStepCell):
             return False
         return True
 
+    def _no_sens_impl(self, *inputs):
+        """construct implementation when the 'sens' parameter is passed in."""
+        loss = self.network(*inputs)
+        sens = F.fill(loss.dtype, loss.shape, self.sens)
+        grads = self.grad_no_sens(self.network, self.weights)(*inputs)
+        grads = self.grad_reducer(grads)
+        if self.use_grad_accumulation:
+            loss = self.gradient_accumulation_process(loss, grads, sens, *inputs)
+        else:
+            if self.enable_dim_reduce:
+                loss = F.depend(loss, self.dim_reduce(loss, grads, sens, self.weights, self.weights_clone, *inputs))
+            elif self.enable_adasum:
+                loss = F.depend(loss, self.adasum_process(loss, grads))
+            else:
+                loss = F.depend(loss, self.optimizer(grads))
+
     def __init_dim_reduce(self):
         """dim reduce algorithm init method."""
         local_pca_mat_path = self.auto_boost.local_pca_mat_path
@@ -390,7 +412,8 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
         network (Cell): The training network. The network only supports single output.
         optimizer (Cell): Optimizer for updating the weights.
         scale_sense (Union[Tensor, Cell]): If this value is Cell type, the loss scaling update logic cell.If this value
-                                          is Tensor type, Tensor with shape :math:`()` or :math:`(1,)`.
+            is Tensor type, :func:`mindspore.nn.TrainOneStepWithLossScaleCell.set_sense_scale` can be called to update
+            loss scale factor, Tensor with shape :math:`()` or :math:`(1,)`.
 
     Inputs:
         - **\*inputs** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`.
@@ -404,7 +427,7 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
 
     Raises:
         TypeError: If `scale_sense` is neither Cell nor Tensor.
-        ValueError: If shape of `scale_sense` is neither (1,) nor ().
+        ValueError: If shape of `scale_sense` is neither :math:`(1,)` nor :math:`()`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -463,9 +486,8 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
         self.loss_scaling_manager = None
         self.base0 = Tensor(0, mstype.int32)
         self.reduce_all = P.ReduceAll(keep_dims=False)
-        self.reduce_any = P.ReduceAny(keep_dims=False)
+        self.logic_not = P.LogicalNot()
         self.equal = P.Equal()
-        self.not_equal = P.NotEqual()
 
         if self.auto_boost.boost_config.get("loss_scale_group", False):
             self.enable_enhanced_amp = True
@@ -544,9 +566,9 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
         flag_sum = self.equal(self.base0, param)
         if self.reducer_flag:
             flag_reduce = self.allreduce(flag_sum)
-            overflow = not self.reduce_all(flag_reduce)
+            overflow = self.logic_not(self.reduce_all(flag_reduce))
         else:
-            overflow = not self.reduce_all(flag_sum)
+            overflow = self.logic_not(self.reduce_all(flag_sum))
 
         if overflow:
             update_ratio = self.reduce_ratio
@@ -647,17 +669,19 @@ class BoostTrainOneStepWithLossScaleCell(BoostTrainOneStepCell):
                 # sum overflow flag over devices
                 flag_reduce = self.allreduce(get_status)
                 # get_status not equal to [0]*8 means overflow
-                flag = self.not_equal(self.base0, flag_reduce)
+                flag = self.equal(self.base0, flag_reduce)
                 status = F.depend(status, flag)
                 # distributed needs to skip allreduce to avoid its overflow affecting the next step
                 clear_status = NPUClearFloatStatusV2()(status)
                 flag = F.depend(flag, clear_status)
+                overall_finite = self.reduce_all(flag)
             else:
                 status = F.depend(status, get_status)
                 clear_status = NPUClearFloatStatusV2()(status)
                 get_status = F.depend(get_status, clear_status)
-                flag = self.not_equal(self.base0, get_status)
-            overflow = self.reduce_any(flag)
+                flag = self.equal(self.base0, get_status)
+                overall_finite = self.reduce_all(flag)
+            overflow = self.logic_not(overall_finite)
         else:
             flag_sum = self.hyper_map(F.partial(_grad_overflow), compute_output)
             flag_sum = P.AddN()(flag_sum)

mindspore/boost/grad_accumulation.py

@@ -71,7 +71,7 @@ class GradientAccumulation(Cell):
 
         if self._accumulation_step >= self._max_accumulation_step:
             loss = F.depend(loss, self.optimizer(self._grad_accumulation))
-            self._accumulation_step = 0
+            F.assign(self._accumulation_step, 0)
 
         if self._accumulation_step == 0:
             loss = F.depend(loss, self.hyper_map(F.partial(gradient_clear_op), self._grad_accumulation))

mindspore/boost/grad_freeze.py

@@ -17,6 +17,7 @@ from __future__ import absolute_import
 from __future__ import division
 
 import numpy as np
+from mindspore import nn
 from mindspore.nn.cell import Cell
 from mindspore.nn.optim import Optimizer
 from mindspore.common import Tensor
@@ -42,7 +43,9 @@ class FreezeOpt(Cell):
     Args:
         opt (Cell): non-freezing optimizer instance, such as 'Momentum', 'SGD'.
         train_parameter_groups (Union[tuple, list]): Groups of parameters for gradients freezing training.
+            Default: ``None`` .
         train_strategy (Union[tuple(int), list(int), Tensor]): Strategy for gradients freezing training.
+            Default: ``None`` .
 
     Supported Platforms:
         ``Ascend``
@@ -201,15 +204,40 @@ class GradientFreeze:
         total_steps (int): Steps of the whole training.
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, Parameter, nn
+        >>> import mindspore.ops as ops
+        >>> from mindspore.nn import WithLossCell
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import boost
+        >>>
+        >>> class Net(nn.Cell):
+        ...    def __init__(self, in_features, out_features):
+        ...        super(Net, self).__init__()
+        ...        self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
+        ...                                name='weight')
+        ...        self.matmul = ops.MatMul()
+        ...
+        ...    def construct(self, x):
+        ...        output = self.matmul(x, self.weight)
+        ...        return output
+        >>> size, in_features, out_features = 16, 16, 10
+        >>> net = Net(in_features, out_features)
+        >>> loss = nn.MSELoss()
+        >>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
+        >>> net_with_loss = WithLossCell(net, loss)
         >>> gradient_freeze_class = boost.GradientFreeze(10, 1, 0.5, 2000)
-        >>> network, optimizer = gradient_freeze_class.freeze_generate(network, optimizer)
+        >>> network, optimizer = gradient_freeze_class.freeze_generate(net_with_loss, optimizer)
+        >>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
+        >>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
+        >>> output = network(inputs, label)
     """
     def __init__(self, param_groups, freeze_type, freeze_p, total_steps):
         self._param_groups = param_groups
         self._freeze_type = freeze_type
         self._freeze_p = freeze_p
         self._total_steps = total_steps
-        self.grad_reducer = F.identity
+        self.grad_reducer = nn.Identity()
 
     def split_parameters_groups(self, net, freeze_para_groups_number):
         r"""
@@ -312,9 +340,9 @@ def freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulat
         sens (numbers.Number):  The scaling number.
         grad (tuple(Tensor)): Tuple of gradient tensors.
         use_grad_accumulation (bool): Use gradient accumulation flag.
-        mean (bool): Gradients mean flag. default: None.
-        degree (int): Device number. default: None.
-        max_accumulation_step (int): Max accumulation steps. default: 1.
+        mean (bool): Gradients mean flag. Default: ``None`` .
+        degree (int): Device number. Default: ``None`` .
+        max_accumulation_step (int): Max accumulation steps. Default: ``1`` .
 
     Examples:
         >>> import numpy as np
@@ -348,7 +376,7 @@ def freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulat
                                              use_grad_accumulation, opt, max_accumulation_step)
                             for reducer, opt in zip(grad_reducers, optimizer.opts))
     else:
-        freeze_nets = tuple(_TrainFreezeCell(network, sens, grad, F.identity,
+        freeze_nets = tuple(_TrainFreezeCell(network, sens, grad, nn.Identity(),
                                              use_grad_accumulation, opt, max_accumulation_step)
                             for opt in optimizer.opts)
     return freeze_nets

mindspore/boost/group_loss_scale_manager.py

@@ -27,7 +27,7 @@ __all__ = ["GroupLossScaleManager"]
 
 
 class GroupLossScaleManager(Cell):
-    """
+    r"""
     Enhanced hybrid precision algorithm supports multi-layer application of different loss scales and
     dynamic updating of loss scales.
 
@@ -41,7 +41,8 @@ class GroupLossScaleManager(Cell):
         - **layer2** (Int) - Last network layer value.
 
     Outputs:
-        - **x** (Tensor) - The output of `_DynamicLossScale` operator.
+        - **out** (Tensor) - A tensor with a group of loss scale tags that marks
+          the loss scale group number of the current tensor.
 
     Supported Platforms:
         ``Ascend``
@@ -80,21 +81,21 @@ class GroupLossScaleManager(Cell):
         >>> param_group1 = []
         >>> param_group2 = []
         >>> for param in net.trainable_params():
-        >>>     if 'conv' in param.name:
-        >>>         param_group1.append(param)
-        >>>     else:
-        >>>         param_group2.append(param)
+        ...     if 'conv' in param.name:
+        ...         param_group1.append(param)
+        ...     else:
+        ...         param_group2.append(param)
         >>> loss_scale_manager.loss_scale_groups = [param_group1, param_group2]
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
-        >>> boost_config_dict = {"boost": {"mode": "manual", "less_bn": False, "grad_freeze": False, "adasum": False, \
-        >>>                      "grad_accumulation": False, "dim_reduce": False, "loss_scale_group": True}}
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None, loss_scale_manager=loss_scale_manager, \
-        >>>               boost_level="O1", boost_config_dict=boost_config_dict)
-        >>> # For details about how to build the dataset, please refer to the variable `dataset_train` in tutorial
-        >>> # document on the official website:
-        >>> # https://www.mindspore.cn/tutorials/zh-CN/r2.0/beginner/quick_start.html
-        >>> dataset = create_custom_dataset()
+        >>> boost_config_dict = {"boost": {"mode": "manual", "less_bn": False, "grad_freeze": False, "adasum": False,
+        ...                      "grad_accumulation": False, "dim_reduce": False, "loss_scale_group": True}}
+        >>> model = ms.train.Model(net, loss_fn=loss, optimizer=optim, metrics=None,
+        ...                        loss_scale_manager=loss_scale_manager,
+        ...                        boost_level="O1", boost_config_dict=boost_config_dict)
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        >>> dataset = create_dataset()
         >>> model.train(2, dataset)
     """
     def __init__(self, init_loss_scale, loss_scale_groups):

mindspore/boost/less_batch_normalization.py

@@ -45,7 +45,7 @@ class CommonHeadLastFN(Cell):
             is same as input x. The values of str refer to the function `initializer`. Default: 'normal'.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
             same as input x. The values of str refer to the function `initializer`. Default: 'zeros'.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: True.
+        has_bias (bool): Specifies whether the layer uses a bias vector. Default: ``True``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -91,10 +91,35 @@ class LessBN(Cell):
 
     Args:
         network (Cell): Network to be modified.
-        fn_flag (bool): Replace FC with FN. default: False.
+        fn_flag (bool): Replace FC with FN. Default: ``False`` .
 
     Examples:
-        >>> network = boost.LessBN(network)
+        >>> import numpy as np
+        >>> from mindspore import Tensor, Parameter, nn
+        >>> import mindspore.ops as ops
+        >>> from mindspore.nn import WithLossCell
+        >>> from mindspore import dtype as mstype
+        >>> from mindspore import boost
+        >>>
+        >>> class Net(nn.Cell):
+        ...    def __init__(self, in_features, out_features):
+        ...        super(Net, self).__init__()
+        ...        self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
+        ...                                name='weight')
+        ...        self.matmul = ops.MatMul()
+        ...
+        ...    def construct(self, x):
+        ...        output = self.matmul(x, self.weight)
+        ...        return output
+        >>> size, in_features, out_features = 16, 16, 10
+        >>> net = Net(in_features, out_features)
+        >>> loss = nn.MSELoss()
+        >>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
+        >>> net_with_loss = WithLossCell(net, loss)
+        >>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
+        >>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
+        >>> train_network = boost.LessBN(net_with_loss)
+        >>> output = train_network(inputs, label)
     """
 
     def __init__(self, network, fn_flag=False):

mindspore/common/__init__.py

@@ -15,20 +15,22 @@
 """Top-level reference to dtype of common module."""
 from __future__ import absolute_import
 from mindspore.common import dtype
-from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class
+from mindspore.common.api import ms_function, ms_memory_recycle, ms_class, jit, jit_class, _no_grad
 from mindspore.common.dtype import Type, int8, byte, int16, short, int32, intc, int64, intp, \
     uint8, ubyte, uint16, ushort, uint32, uintc, uint64, uintp, float16, half, \
-    float32, single, float64, double, bool_, float_, list_, tuple_, int_, \
-    uint, number, tensor, string, type_none, tensor_type, Int, \
-    complex64, complex128, dtype_to_nptype, _null, _null_type, \
+    float32, single, float64, bfloat16, double, bool_, float_, list_, tuple_, int_, \
+    uint, number, tensor_type, string, type_none, TensorType, Int, \
+    complex64, complex128, dtype_to_nptype, _null, _NullType, \
     dtype_to_pytype, pytype_to_dtype, get_py_obj_dtype, QuantDtype
 from mindspore.common.dump import set_dump
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.seed import set_seed, get_seed
-from mindspore.common.tensor import Tensor
+from mindspore.common.tensor import Tensor, tensor
 from mindspore.common.sparse_tensor import RowTensor, RowTensorInner, SparseTensor, COOTensor, CSRTensor
 from mindspore.common.mutable import mutable
 from mindspore.common.jit_config import JitConfig
+from mindspore.common.lazy_inline import lazy_inline
+from mindspore.common.mindir_util import load_mindir, save_mindir
 
 # symbols from dtype
 __all__ = [
@@ -46,24 +48,26 @@ __all__ = [
     "bool_", "float_",
     "list_", "tuple_",
     "int_", "uint",
-    "number", "tensor",
+    "number", "tensor_type",
     "string", "type_none",
     "_null",
-    "tensor_type", "QuantDtype",
-    "Type", "Int", "_null_type",
+    "TensorType", "QuantDtype",
+    "Type", "Int", "_NullType",
     "complex64", "complex128",
     # __method__ from dtype
     "dtype_to_nptype", "dtype_to_pytype",
-    "pytype_to_dtype", "get_py_obj_dtype"
+    "pytype_to_dtype", "get_py_obj_dtype",
+    "bfloat16",
 ]
 
 __all__.extend([
-    "Tensor", "RowTensor", "SparseTensor", "COOTensor", "CSRTensor", # tensor
-    "ms_function", "ms_class", 'jit', 'jit_class',  # api
+    "tensor", "Tensor", "RowTensor", "SparseTensor", "COOTensor", "CSRTensor", # tensor
+    "ms_function", "ms_class", 'jit', 'jit_class', '_no_grad',  # api
     "Parameter", "ParameterTuple",  # parameter
     "dtype",
     "set_seed", "get_seed",  # random seed
     "set_dump",
     "ms_memory_recycle",
     "mutable", "JitConfig",
+    "lazy_inline", "load_mindir", "save_mindir"
 ])

mindspore/common/_auto_dynamic.py

@@ -0,0 +1,68 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""convert inputs to dynamic shape automatically at the first round. Method in this file is only used for test."""
+import os
+from mindspore.common.parameter import Parameter
+from mindspore.common.tensor import Tensor
+
+
+def is_auto_dynamic_shape():
+    """this is used only for test"""
+    return os.getenv("MS_DEV_AUTO_DYNAMIC_SHAPE") == "on"
+
+
+def is_auto_dynamic_rank():
+    """this is used only for test"""
+    return os.getenv("MS_DEV_AUTO_DYNAMIC_RANK") == "on"
+
+
+def is_auto_dynamic():
+    """this is used only for test"""
+    return is_auto_dynamic_shape() or is_auto_dynamic_rank()
+
+
+def convert_inputs_to_dynamic(*inputs):
+    """this is used only for test"""
+    dyn_inputs = list(inputs)
+    if not dyn_inputs:
+        return None
+    for idx, net_input in enumerate(inputs):
+        if isinstance(net_input, Tensor) and not isinstance(net_input, Parameter):
+            shp = net_input.shape
+            if not shp:
+                dyn_inputs[idx] = net_input
+                continue
+            if is_auto_dynamic_rank():
+                dyn_tensor = Tensor(shape=None, dtype=net_input.dtype)
+            else:
+                dyn_shape = [None for _ in net_input.shape]
+                dyn_tensor = Tensor(shape=dyn_shape, dtype=net_input.dtype)
+            dyn_inputs[idx] = dyn_tensor
+
+    return tuple(dyn_inputs)
+
+
+def convert_new_shapes(dataset_shapes):
+    """this is used only for test"""
+    new_shapes = []
+    for shape in dataset_shapes:
+        if is_auto_dynamic_rank():
+            new_shape = [-2]
+        else:
+            new_shape = [-1 for _ in shape]
+        new_shapes.append(new_shape)
+    return new_shapes

mindspore/common/_jit_fallback_utils.py

@@ -0,0 +1,111 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""common _jit_fallback_utils."""
+
+
+_local_value_nodes = {}
+
+
+def generate_list(key_name, list_value):
+    "Generate list object."
+    list_obj = get_local_variable(key_name)
+    # Need to clear current object, in case the same make_list is called multiple times.
+    list_obj.clear()
+    list_obj.extend(list_value)
+    return list_obj
+
+
+def get_local_variable(name):
+    """Get the local variable according name."""
+    return _local_value_nodes.get(name)
+
+
+def set_local_variable(name, value):
+    """Set the local variable with name and value."""
+    _local_value_nodes[name] = value
+
+
+def dict_setitem(dic, key, val):
+    """Set an element to dict."""
+    dic.__setitem__(key, val)
+    return dic
+
+
+def list_inplace_append(list_obj, target_obj):
+    """Inplace append target_obj to list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.append(target_obj)
+    return list_obj
+
+
+def list_inplace_extend(list_obj, target_obj):
+    """Inplace extend target_obj to list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.extend(target_obj)
+    return list_obj
+
+
+def list_inplace_insert(list_obj, index, target_obj):
+    """Inplace insert target_obj to list_obj at position index for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.insert(index, target_obj)
+    return list_obj
+
+
+def list_inplace_pop(list_obj, index):
+    """Inplace pop list_obj element at position index for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.pop(index)
+    return list_obj
+
+
+def list_inplace_reverse(list_obj):
+    """Inplace reverse list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.reverse()
+    return list_obj
+
+
+def list_inplace_clear(list_obj):
+    """Inplace clear list_obj for jit fallback."""
+    # When input list is empty list, it will be converted to tuple.
+    # This will be removed after empty list problem is solved.
+    if isinstance(list_obj, tuple) and not list_obj == 0:
+        list_obj = []
+    list_obj.clear()
+    return list_obj
+
+
+def dict_inplace_setitem(dict_obj, key, target):
+    """Inplace dictionary setitem operation for dict_obj."""
+    dict_obj[key] = target
+    return dict_obj

mindspore/common/_register_for_adapter.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,14 +15,14 @@
 
 """Registry MSAdapter config."""
 
-from mindspore.common.tensor import Tensor
-
 
 class Registry:
     """Registry class for ms adapter."""
 
     def __init__(self):
+        self.is_registered = False
         self._tensor = None
+        self._parameter = None
         self._convert_map = {}
 
     @property
@@ -32,6 +32,13 @@ class Registry:
             raise ValueError("Before using Tensor in MSAdapter, please call 'set_adapter_config'.")
         return self._tensor
 
+    @property
+    def parameter(self):
+        """Return the registered parrameter."""
+        if self._parameter is None:
+            raise ValueError("Before using Parameter in MSAdapter, please call 'set_adapter_config'.")
+        return self._parameter
+
     @property
     def convert_map(self):
         """Return the registered convert map."""
@@ -41,9 +48,14 @@ class Registry:
         """Register the tensor of ms adapter."""
         if self._tensor is not None:
             raise ValueError("Repeated registration of tensor in ms adapter config.")
-        if not issubclass(value, Tensor):
-            raise ValueError(f"The tensor definition here should be a subclass of ms.Tensor, but got {value}.")
         self._tensor = value
+        self.is_registered = True
+
+    def register_parameter(self, value):
+        """Register the parameter of ms adapter."""
+        if self._parameter is not None:
+            raise ValueError("Repeated registration of Parameter in ms adapter config.")
+        self._parameter = value
 
     def register_convert_map(self, value):
         """Register the convert map of ms adapter."""

mindspore/common/_register_for_tensor.py

@@ -17,7 +17,7 @@
 
 from __future__ import absolute_import
 from collections import UserDict
-from mindspore import context
+from mindspore._c_expression import Tensor as Tensor_
 
 
 class Registry(UserDict):
@@ -31,7 +31,7 @@ class Registry(UserDict):
         """Get the value by str."""
         if not isinstance(obj_str, str):
             raise TypeError("key for tensor registry must be string.")
-        if context.get_context("enable_ge"):
+        if Tensor_._is_test_stub() is True:  # pylint: disable=W0212
             def wrap(*args):
                 new_args = list(args)
                 new_args.append(obj_str)