mindspore 2.4.0__cp310-cp310-macosx_11_0_arm64.whl

mindspore/common/jit_config.py

@@ -0,0 +1,98 @@
+# 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.
+# 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.
+# ============================================================================
+"""JitConfig for compile."""
+
+class JitConfig:
+    """
+    Jit config for compile.
+
+    Args:
+        jit_level (str, optional): Used to control the compilation optimization level.
+            Supports ["O0", "O1", "O2"]. Default: ``""`` , The framework automatically selects the execution method.
+            Not recommended, it is recommended to use the jit decorator.
+
+            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off,
+              adopt KernelByKernel execution mode.
+            - ``"O1"``: Using commonly used optimizations and automatic operator fusion optimizations,
+              adopt KernelByKernel execution mode.
+            - ``"O2"``: Ultimate performance optimization, adopt Sink execution mode.
+
+        exc_mode (str, optional): Control the execution mode of the model.
+            Supports ["auto", "sink", "no_sink"]. Default: ``"auto"`` .
+
+            - ``"auto"``: The framework automatically selects the execution method.
+            - ``"sink"``: Support the network to load and load the entire device at once, and then execute it by
+              input driver, without the need to iterate through each operator to achieve better execution performance.
+              This mode is only supported on the Ascend backend.
+            - ``"no_sink"``: The network model is executed asynchronously one by one using a single operator.
+
+        jit_syntax_level (str, optional): JIT syntax level for graph compiling.
+            The value must be ``"STRICT"`` , ``"LAX"`` or ``""`` . Default to an empty string, which means that this
+            JitConfig configuration will be ignored and the jit_syntax_level of ms.context will be used.
+            For more details about ms.context, refer to
+            `set_context <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html>`_ .
+            Default: ``""`` .
+
+            - ``"STRICT"``: Only basic syntax is supported, and execution performance is optimal. Can be used for MindIR
+              load and export.
+            - ``"LAX"``: Compatible with all Python syntax as much as possible. However, execution performance may be
+              affected and not optimal. Cannot be used for MindIR load and export due to some syntax that may not be
+              able to be exported.
+
+        debug_level (str, optional): Set debugging level for graph compiling.
+            The value must be ``"RELEASE"`` or ``"DEBUG"``. Default value: ``RELEASE``.
+
+            - ``RELEASE``: Used for normally running, and some debug information will be discard to get a better
+              compiling performance.
+            - ``DEBUG``: Used for debugging when errors occur, more information will be record in compiling process.
+
+        infer_boost (str, optional): enable infer boost mode.
+            The value must be ``"on"`` , ``"off"``. Default to an "off", which means that disable infer boost.
+            when infer boost mode is enabled, MindSpore will use high perf kernel lib, use faster runtime make
+            infer speed is best.
+            Note: current infer boost only support `jit_level` == ``"O0"`` and only Atlas A2 series products
+            are supported.
+
+        **kwargs (dict): A dictionary of keyword arguments that the class needs.
+
+    Examples:
+        >>> from mindspore import JitConfig
+        >>>
+        >>> jitconfig = JitConfig(jit_level="O1")
+        >>>
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>>
+        >>> net.set_jit_config(jitconfig)
+    """
+    def __init__(self, jit_level="", exc_mode="auto", jit_syntax_level="", debug_level="RELEASE",
+                 infer_boost="off", **kwargs):
+        if jit_level not in ["", "O0", "O1", "O2"]:
+            raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
+        if exc_mode not in ["auto", "sink", "no_sink"]:
+            raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
+        if jit_syntax_level != "" and jit_syntax_level not in ["STRICT", "COMPATIBLE", "LAX"]:
+            raise ValueError("For 'jit_syntax_level' must be one of '['STRICT', 'LAX']'.")
+        if debug_level not in ["RELEASE", "DEBUG"]:
+            raise ValueError("For 'debug_level' must be one of '['RELEASE', 'DEBUG']'.")
+        if infer_boost != "" and infer_boost not in ["on", "off"]:
+            raise ValueError("For 'infer_boost' must be one of '['on', 'off']'.")
+        self.jit_config_dict = kwargs
+        self.jit_config_dict["jit_level"] = jit_level
+        self.jit_config_dict["exc_mode"] = exc_mode
+        self.jit_config_dict["jit_syntax_level"] = jit_syntax_level
+        self.jit_config_dict["debug_level"] = debug_level
+        self.jit_config_dict["infer_boost"] = infer_boost

mindspore/common/lazy_inline.py

@@ -0,0 +1,240 @@
+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""lazy_inline"""
+from __future__ import absolute_import
+import inspect
+from functools import wraps
+from mindspore import log as logger
+
+
+def lazy_inline(fn=None, attrs=None, policy=None):
+    """
+    Make the cell to be reusable. The corresponding sub graph will not be inline at first
+    and will be inline with the policy.
+    Registering the decorator of the built-in function `__init__` of a cell, the decorator
+    will add the parameters of `__init__` according to the `attrs` as the attributes of this cell.
+
+    .. warning::
+        This feature is only supported on Ascend and is not supported on other hardwares.
+        The construct parameters must be positional or key word arguments and have not default values.
+        The cell has not switch sub graph.
+
+    Args:
+        fn (function): `__init__` function of a cell.
+        attrs (Union[list[string], string]): The attributes list to add for the cell.
+        policy (Union[None, "front"]): The policy of inline. Default is None.
+
+            - ``None``: The cell will be compiled to sub graph and will not be inline.
+            - ``"front"``: The cell will be compiled to sub graph first and will be inline at front end.
+
+    Returns:
+        function, original function.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.nn as nn
+        >>> from mindspore import lazy_inline
+        >>> from mindspore import context
+        >>> from mindspore import ops
+        >>> def conv3x3(in_channels, out_channels, stride=1, padding=1, pad_mode='pad'):
+        ...     return nn.Conv2d(in_channels, out_channels,
+        ...                      kernel_size=3, stride=stride, padding=padding, pad_mode=pad_mode)
+        ...
+        >>> def conv1x1(in_channels, out_channels, stride=1, padding=0, pad_mode='pad'):
+        ...     return nn.Conv2d(in_channels, out_channels,
+        ...                      kernel_size=1, stride=stride, padding=padding, pad_mode=pad_mode)
+        ...
+        >>> class Block(nn.Cell):
+        ...     expansion = 4
+        ...
+        ...     @lazy_inline
+        ...     def __init__(self,
+        ...                  in_channels,
+        ...                  out_channels,
+        ...                  stride=1,
+        ...                  down_sample=False):
+        ...         super(Block, self).__init__()
+        ...
+        ...         out_chls = out_channels
+        ...         self.conv1 = conv1x1(in_channels, out_chls, stride=1, padding=0)
+        ...         self.bn1 = nn.BatchNorm2d(out_chls)
+        ...
+        ...         self.conv2 = conv3x3(out_chls, out_chls, stride=stride, padding=1)
+        ...         self.bn2 = nn.BatchNorm2d(out_chls)
+        ...
+        ...         self.conv3 = conv1x1(out_chls, out_channels, stride=1, padding=0)
+        ...         self.bn3 = nn.BatchNorm2d(out_channels)
+        ...
+        ...         self.relu = nn.ReLU()
+        ...         self.downsample = down_sample
+        ...
+        ...         self.conv_down_sample = conv1x1(in_channels, out_channels,
+        ...                                         stride=stride, padding=0)
+        ...         self.bn_down_sample = nn.BatchNorm2d(out_channels)
+        ...         self.add = ops.Add()
+        ...
+        ...     def construct(self, x):
+        ...         identity = x
+        ...
+        ...         out = self.conv1(x)
+        ...         out = self.bn1(out)
+        ...         out = self.relu(out)
+        ...
+        ...         out = self.conv2(out)
+        ...         out = self.bn2(out)
+        ...         out = self.relu(out)
+        ...
+        ...         out = self.conv3(out)
+        ...         out = self.bn3(out)
+        ...
+        ...         if self.downsample:
+        ...             identity = self.conv_down_sample(identity)
+        ...             identity = self.bn_down_sample(identity)
+        ...
+        ...         out = self.add(out, identity)
+        ...         out = self.relu(out)
+        ...
+        ...         return out
+        ...
+        >>> class Net(nn.Cell):
+        ...     def __init__(self, block, num_classes=100):
+        ...         super(Net, self).__init__()
+        ...
+        ...         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, pad_mode='pad')
+        ...         self.bn1 = nn.BatchNorm2d(64)
+        ...         self.relu = nn.ReLU()
+        ...         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='valid')
+        ...
+        ...         self.layer = self.MakeLayer(
+        ...             block, 50, in_channels=64, out_channels=2048, stride=2)
+        ...         self.avgpool = nn.AvgPool2d(7, 1)
+        ...         self.flatten = ops.Flatten()
+        ...
+        ...     def MakeLayer(self, block, layer_num, in_channels, out_channels, stride):
+        ...         layers = []
+        ...         resblk = block(in_channels, out_channels,
+        ...                        stride=stride, down_sample=True)
+        ...         layers.append(resblk)
+        ...
+        ...         for _ in range(1, layer_num):
+        ...             resblk = block(out_channels, out_channels, stride=1)
+        ...             layers.append(resblk)
+        ...
+        ...         return nn.SequentialCell(layers)
+        ...
+        ...     def construct(self, x):
+        ...         x = self.conv1(x)
+        ...         x = self.bn1(x)
+        ...         x = self.relu(x)
+        ...         x = self.maxpool(x)
+        ...         x = self.layer(x)
+        ...         x = self.avgpool(x)
+        ...         x = self.flatten(x)
+        ...         return x
+        ...
+        >>> def test_compile():
+        ...     net = Net(Block)
+        ...     inp = Tensor(np.ones([1, 3, 224, 224]).astype(np.float32))
+        ...     net(inp)
+        ...
+        >>> context.set_context(mode=context.GRAPH_MODE,
+        ...                     save_graphs=True, save_graphs_path="./lazy")
+        ...
+        >>> test_compile()
+    """
+
+    def lazy_inline_wrap(fn):
+        if inspect.isclass(fn):
+            tips = "The lazy_inline should decorate the __init__ function, not the class {}.".format(fn.__name__) \
+                   + " File: " + inspect.getfile(fn)
+            raise ValueError(tips)
+        if fn.__name__ != "__init__":
+            tips = "The lazy_inline should decorate the __init__ function, not the function: {}.".format(fn.__name__) \
+                   + " line: " + str(fn.__code__.co_firstlineno) + " in " \
+                   + fn.__code__.co_filename
+            raise ValueError(tips)
+
+        def check_parameters(self):
+            if hasattr(fn, "has_tips_"):
+                return
+
+            if hasattr(self, "construct"):
+                params = inspect.signature(self.construct).parameters
+                err = False
+                tips = "The function construct's parameters: "
+                for name, parm in params.items():
+                    if parm.default != inspect.Parameter.empty:
+                        if err:
+                            tips += " , " + name
+                        else:
+                            err = True
+                            tips += " " + name
+
+                if err:
+                    tips += " must be  key word or positional arguments and can't have default values." \
+                            + " line: " + str(self.construct.__code__.co_firstlineno) \
+                            + " in " + self.construct.__code__.co_filename
+                    logger.info(tips)
+                    fn.has_tips_ = True
+
+            else:
+                tips = "The " + self.__class__.__name__ + " must be a cell and must has a construct function." \
+                       + " line: " + str(fn.__code__.co_firstlineno) + " in " + fn.__code__.co_filename
+                logger.warning(tips)
+                fn.has_tips_ = True
+
+        @wraps(fn)
+        def lazy_inline_deco(self, *args, **kwargs):
+            check_parameters(self)
+            new_args = []
+            if attrs is None:
+                bound_args = inspect.signature(fn).bind(self, *args, **kwargs)
+                new_args = bound_args.arguments
+                del new_args['self']
+                new_args = new_args.values()
+            fn(self, *args, **kwargs)
+
+            if isinstance(policy, str) and policy == "front":
+                self.no_inline = False
+            elif policy is not None:
+                raise ValueError(f"policy must be None or 'front'")
+
+            if attrs is None:
+                self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(new_args)
+                return
+
+            if isinstance(attrs, list):
+                for attr in attrs:
+                    if not isinstance(attr, str):
+                        raise ValueError(f"attr must be a string")
+                    if hasattr(self, attr):
+                        new_args.append(getattr(self, attr))
+            elif isinstance(attrs, str):
+                if hasattr(self, attrs):
+                    new_args = getattr(self, attrs)
+            else:
+                raise ValueError(f"attrs must be list or string")
+            self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(new_args)
+
+        return lazy_inline_deco
+
+    if fn is not None:
+        return lazy_inline_wrap(fn)
+    return lazy_inline_wrap

mindspore/common/mindir_util.py

@@ -0,0 +1,111 @@
+# 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.
+# ============================================================================
+"""mindir utility."""
+from __future__ import absolute_import
+
+import os
+import stat
+from mindspore import log as logger
+from mindspore import _checkparam as Validator
+from mindspore.train.mind_ir_pb2 import ModelProto as mindir_model
+
+
+def load_mindir(file_name):
+    """
+    load protobuf file.
+
+    Args:
+        file_name (str): File name.
+
+    Returns:
+        ModelProto, mindir proto object.
+
+    Raises:
+        ValueError: The file does not exist or the file name format is incorrect.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> md = ms.load_mindir("test.mindir")
+    """
+
+    Validator.check_file_name_by_regular(file_name)
+    file_name = os.path.realpath(file_name)
+    model = mindir_model()
+
+    try:
+        with open(file_name, "rb") as f:
+            pb_content = f.read()
+            model.ParseFromString(pb_content)
+    except BaseException as e:
+        logger.critical(f"Failed to parse the file: {file_name} "
+                        f" please check the correct file.")
+        raise ValueError(e.__str__()) from e
+    finally:
+        pass
+
+    return model
+
+
+def save_mindir(model, file_name):
+    """
+    save protobuf file.
+
+    Args:
+        model (ModelProto): mindir model
+        file_name (str): File name.
+
+    Raises:
+        TypeError: The argument `model` is not a ModelProto object.
+        ValueError: The file path does not exist or the `file_name` format is incorrect.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> md = ms.load_mindir("test.mindir")
+        >>> md.user_info["version"]="pangu v100"
+        >>> ms.save_mindir(md,"test_new.mindir")
+        >>> md_new = ms.load_mindir("test_new.mindir")
+        >>> md_new.user_info
+    """
+
+    Validator.check_file_name_by_regular(file_name)
+    file_name = os.path.realpath(file_name)
+    if not file_name.endswith('.mindir'):
+        file_name += ".mindir"
+
+    current_path = os.path.realpath(file_name)
+    dirname = os.path.dirname(current_path)
+    os.makedirs(dirname, mode=0o700, exist_ok=True)
+    if os.path.exists(file_name):
+        os.chmod(file_name, stat.S_IWUSR)
+
+    if not isinstance(model, mindir_model):
+        raise TypeError("For 'save_mindir', the argument 'model' must be ModelProto, "
+                        "but got {}.".format(type(model)))
+    try:
+        with os.fdopen(os.open(file_name, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "wb") as f:
+            f.write(model.SerializeToString())
+    except BaseException as e:
+        logger.critical(f"Failed to save the file: {file_name} ,"
+                        f" please check the correct file.")
+        raise ValueError(e.__str__()) from e
+    finally:
+        if os.path.exists(file_name):
+            os.chmod(file_name, stat.S_IRUSR)

mindspore/common/mutable.py

@@ -0,0 +1,234 @@
+# Copyright 2022-2024 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.
+# ============================================================================
+"""mutable function for setting constants mutable."""
+from __future__ import absolute_import
+
+from mindspore.common.tensor import Tensor
+from mindspore._c_expression import Tensor as Tensor_
+from mindspore import log as logger
+
+_check_elements_set = set()
+
+
+class _Int(int):
+    pass
+
+
+class _Float(float):
+    pass
+
+
+class _Tuple(tuple):
+    pass
+
+
+class _List(list):
+    pass
+
+
+class _Dict(dict):
+    pass
+
+
+# pylint: disable=super-init-not-called
+class _Bool(int):
+    """Define a _Bool class that inherits from int, because base class 'bool' is a marked final."""
+    def __init__(self, value):
+        self.value = bool(value)
+
+    @property
+    def __class__(self):
+        return bool
+
+    def __and__(self, x):
+        return self.value & x
+
+    def __rand__(self, x):
+        return x & self.value
+
+    def __or__(self, x):
+        return self.value | x
+
+    def __ror__(self, x):
+        return x | self.value
+
+    def __xor__(self, x):
+        return self.value ^ x
+
+    def __rxor__(self, x):
+        return x ^ self.value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return repr(self.value)
+
+    def __ms_mutable_bool__(self):
+        pass
+
+
+def _check_element_type_recursion(value):
+    """Check if all the elements are valid or self reference."""
+    if id(value) in _check_elements_set:
+        return False
+    _check_elements_set.add(id(value))
+
+    if isinstance(value, (tuple, list)):
+        for element in value:
+            if not _check_element_type_recursion(element):
+                return False
+            _check_elements_set.remove(id(element))
+        return True
+    if isinstance(value, dict):
+        for element in value.values():
+            if not _check_element_type_recursion(element):
+                return False
+            _check_elements_set.remove(id(element))
+        return True
+    return isinstance(value, (Tensor, Tensor_, int, float))
+
+
+def _check_element_type(value):
+    """Check if all the elements are valid."""
+    flag = _check_element_type_recursion(value)
+    _check_elements_set.clear()
+    return flag
+
+
+def mutable(input_data, dynamic_len=False):
+    """
+    Make a constant value mutable.
+
+    Currently, all the inputs of Cell except Tensor such as scalar, tuple, list and dict, are regarded as constant
+    values. The constant values are non-differentiable and used to do constant folding in the optimization process.
+
+    Besides, currently when the network input is tuple[Tensor], list[Tensor] or dict[Tensor], even without changing
+    the shape and dtype of the Tensors, the network will be re-compiled when calling this network repeatedly because
+    the these inputs are regarded as constant values.
+
+    To solve the above problems, we provide api `mutable` to make the constant inputs of Cell 'mutable'. A 'mutable'
+    input means that it is changed to be a variable input just like Tensor and the most important thing is that it
+    will be differentiable.
+
+    When the `input_data` is tuple or list and `dynamic_len` is False, `mutable` will return a constant length tuple
+    or list with all mutable elements. If `dynamic_len` is True, the length of the return tuple or list will be dynamic.
+
+    If a dynamic length tuple or list is used as the input of the network and the network is repeatedly called, and
+    the length of the tuple or list is different for each run, it does not need to be re-compiled.
+
+    Args:
+        input_data (Union[Tensor, scalar, tuple, list, dict]): The input data to be made mutable. If
+            'input_data' is list/tuple/dict, the type of each element should also in the valid types.
+        dynamic_len (bool): Whether to set the whole sequence to be dynamic length. In graph compilation, if
+            `dynamic_len` is ``True`` , the `input_data` must be list or tuple and the elements of `input_data` must
+            have the same type and shape. Default: ``False`` .
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+        `dynamic_len` is an experimental argument. Currently, `dynamic_len` is not supported to be ``True`` .
+
+    Note:
+        Currently this api only works in GRAPH mode.
+
+    Returns:
+        The origin input data which has been set mutable.
+
+    Raises:
+        TypeError: If `input_data` is not one of Tensor, scalar, tuple, list, dict or their nested structure.
+        TypeError: If `dynamic_len` is ``True`` and `input_data` is not tuple or list.
+        ValueError: If `dynamic_len` is ``True`` , `input_data` is tuple or list but the elements within `input_data`
+            do not have the same type.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import mutable, nn, ops, Tensor, context
+        >>> from mindspore import dtype as mstype
+        >>> context.set_context(mode=context.GRAPH_MODE)
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.matmul = ops.MatMul()
+        ...
+        ...     def construct(self, z):
+        ...         x = z[0]
+        ...         y = z[1]
+        ...         out = self.matmul(x, y)
+        ...         return out
+        ...
+        >>> class GradNetWrtX(nn.Cell):
+        ...     def __init__(self, net):
+        ...         super(GradNetWrtX, self).__init__()
+        ...         self.net = net
+        ...         self.grad_op = ops.GradOperation()
+        ...
+        ...     def construct(self, z):
+        ...         gradient_function = self.grad_op(self.net)
+        ...         return gradient_function(z)
+        ...
+        >>> z = mutable((Tensor([[0.5, 0.6, 0.4], [1.2, 1.3, 1.1]], dtype=mstype.float32),
+        ...              Tensor([[0.01, 0.3, 1.1], [0.1, 0.2, 1.3], [2.1, 1.2, 3.3]], dtype=mstype.float32)))
+        >>> output = GradNetWrtX(Net())(z)
+        >>> print(output)
+        (Tensor(shape=[2, 3], dtype=Float32, value=
+        [[ 1.41000009e+00,  1.60000002e+00,  6.59999943e+00],
+         [ 1.41000009e+00,  1.60000002e+00,  6.59999943e+00]]), Tensor(shape=[3, 3], dtype=Float32, value=
+        [[ 1.70000005e+00,  1.70000005e+00,  1.70000005e+00],
+         [ 1.89999998e+00,  1.89999998e+00,  1.89999998e+00],
+         [ 1.50000000e+00,  1.50000000e+00,  1.50000000e+00]]))
+    """
+    if not _check_element_type(input_data):
+        raise TypeError(
+            f"For 'mutable', the 'input_data' should be one of (bool, int, float, Tensor, tuple, list, dict) "
+            f"or their nested structures with no self-reference, but got {type(input_data).__name__}: {input_data}.")
+
+    if not isinstance(dynamic_len, bool):
+        raise TypeError(f"For 'mutable', the second input should be bool, but got: {type(input_data).__name__}")
+
+    if dynamic_len and not isinstance(input_data, (tuple, list)):
+        raise TypeError(
+            f"For 'mutable', when the variable_len is True, the first input should be list or tuple, "
+            f"but got: {type(input_data).__name__}")
+
+    ret = input_data
+    if isinstance(input_data, bool):
+        ret = _Bool(input_data)
+    elif isinstance(input_data, int):
+        ret = _Int(input_data)
+    elif isinstance(input_data, float):
+        ret = _Float(input_data)
+    elif isinstance(input_data, list):
+        ret = _List(input_data)
+    elif isinstance(input_data, tuple):
+        ret = _Tuple(input_data)
+    elif isinstance(input_data, dict):
+        ret = _Dict(input_data)
+    elif isinstance(input_data, Tensor):
+        logger.info("For 'mutable', the Tensor in 'input_data' must not be constant. \
+                     We will add set_const_arg=False statement automatically.")
+        ret.set_const_arg(False)
+    elif isinstance(input_data, Tensor_):
+        ret = Tensor(input_data, internal=True)
+        logger.info("For 'mutable', the Tensor_ in 'input_data' must not be constant. \
+                     We will add set_const_arg=False statement automatically.")
+        ret.set_const_arg(False)
+
+    setattr(ret, "__ms_mutable__", True)
+    setattr(ret, "__ms_dynamic_len__", dynamic_len)
+    setattr(ret, "__ms_origin_object__", input_data)
+    _check_elements_set.clear()
+    return ret