mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/common/dtype.py

@@ -17,20 +17,25 @@
 """Data type for MindSpore."""
 from __future__ import absolute_import
 
+import builtins
 import enum
 from inspect import isfunction
 import numpy as np
+from mindspore import log as logger
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
-from mindspore._c_expression.np_dtypes import np_version_valid
-if np_version_valid(False):
+from mindspore._c_expression.np_dtypes import np_dtype_valid
+
+if np_dtype_valid(False):
     from mindspore._c_expression.np_dtypes import bfloat16 as np_bfloat16
 
+# bool, int, float are not defined in __all__ to avoid conflict with built-in types.
 __dtype__ = [
+    "bool_",
     "int8", "byte",
     "int16", "short",
     "int32", "intc",
-    "int64", "intp",
+    "int64", "long", "intp",
     "uint8", "ubyte",
     "uint16", "ushort",
     "uint32", "uintc",
@@ -38,15 +43,15 @@ __dtype__ = [
     "float16", "half",
     "float32", "single",
     "float64", "double",
-    "bool_", "float_",
-    "list_", "tuple_",
-    "int_", "uint",
+    "complex64", "cfloat",
+    "complex128", "cdouble",
+    "qint4x2", "bfloat16",
+    "float8_e4m3fn", "float8_e5m2", "hifloat8",
+    "int_", "uint", "float_",
+    "list_", "tuple_", "string",
     "number", "tensor_type",
-    "string", "type_none",
-    "TensorType", "_null",
-    "Type", "Int",
-    "complex64", "complex128",
-    "bfloat16", "qint4x2"
+    "type_none", "_null",
+    "TensorType", "Type", "Int",
 ]
 
 __method__ = [
@@ -59,16 +64,18 @@ __all__.extend(__dtype__)
 __all__.extend(__method__)
 
 # type definition
-bool_ = typing.kBool
+bool = typing.kBool
+bool_ = bool
 
-qint4x2 = typing.kInt4
 int8 = typing.kInt8
 byte = int8
 int16 = typing.kInt16
 short = int16
 int32 = typing.kInt32
+int = int32
 intc = int32
 int64 = typing.kInt64
+long = int64
 intp = int64
 
 uint8 = typing.kUInt8
@@ -83,12 +90,21 @@ uintp = uint64
 float16 = typing.kFloat16
 half = float16
 float32 = typing.kFloat32
+float = float32
 single = float32
 float64 = typing.kFloat64
 double = float64
+
+qint4x2 = typing.kInt4
+float8_e4m3fn = typing.kFloat8E4M3FN
+float8_e5m2 = typing.kFloat8E5M2
+hifloat8 = typing.kHiFloat8
 bfloat16 = typing.kBFloat16
+
 complex64 = typing.kComplex64
+cfloat = complex64
 complex128 = typing.kComplex128
+cdouble = complex128
 
 number = typing.kNumber
 int_ = typing.kInt
@@ -131,39 +147,25 @@ AnythingType = typing.TypeAny
 RefType = typing.RefType
 _NullType = typing.TypeNull
 
-number_type = (int8,
-               int16,
-               int32,
-               int64,
-               uint8,
-               uint16,
-               uint32,
-               uint64,
-               float16,
-               float32,
-               float64,
-               bfloat16,
-               complex64,
-               complex128,
-               qint4x2,)
+number_type = (int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, bfloat16, complex64,
+               complex128, qint4x2, float8_e4m3fn, float8_e5m2, hifloat8)
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64, bfloat16,)
-signed_type = (int8, byte, int16, short, int32, intc, int64,
-               intp, float16, half, float32, single, float64,
-               double, bfloat16, complex64, complex128)
+float_type = (float16, float32, float64, bfloat16, float8_e4m3fn, float8_e5m2, hifloat8)
+signed_type = (int8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128, qint4x2,
+               float8_e4m3fn, float8_e5m2, hifloat8)
 complex_type = (complex64, complex128,)
-all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, bfloat16, complex64, complex128)
-implicit_conversion_seq = {t: idx for idx, t in enumerate(all_types)}
+all_types = (bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, bfloat16,
+             complex64, complex128, qint4x2, float8_e4m3fn, float8_e5m2, hifloat8)
 
 _simple_types = {
     list: list_,
     tuple: tuple_,
     type(None): type_none,
-    bool: bool_,
-    int: int64,
-    float: float64,
+    builtins.bool: bool_,
+    builtins.int: int64,
+    builtins.float: float64,
     complex: complex128,
     str: string,
     np.bool_: bool_,
@@ -186,6 +188,9 @@ def pytype_to_dtype(obj):
     """
     Convert python type to MindSpore type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         obj (type): A python type object.
 
@@ -201,6 +206,15 @@ def pytype_to_dtype(obj):
         >>> print(out)
         Bool
     """
+    logger.warning("The interface 'mindspore.pytype_to_dtype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _pytype_to_dtype(obj)
+
+
+def _pytype_to_dtype(obj):
+    """
+    Convert python type to MindSpore type.
+    """
 
     if isinstance(obj, np.dtype):
         obj = obj.type
@@ -218,6 +232,9 @@ def get_py_obj_dtype(obj):
     """
     Get the MindSpore data type, which corresponds to python type or variable.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         obj (type): An object of python type, or a variable of python type.
 
@@ -229,6 +246,15 @@ def get_py_obj_dtype(obj):
         >>> ms.get_py_obj_dtype(1)
         mindspore.int64
     """
+    logger.warning("The interface 'mindspore.get_py_obj_dtype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _get_py_obj_dtype(obj)
+
+
+def _get_py_obj_dtype(obj):
+    """
+    Get the MindSpore data type, which corresponds to python type or variable.
+    """
     # Tensor
     if hasattr(obj, 'shape') and hasattr(obj, 'dtype') and isinstance(obj.dtype, typing.Type):
         return TensorType(obj.dtype)
@@ -252,6 +278,9 @@ def dtype_to_nptype(type_):
     r"""
     Convert MindSpore dtype to numpy data type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         type\_ (:class:`mindspore.dtype`): MindSpore's dtype.
 
@@ -263,6 +292,15 @@ def dtype_to_nptype(type_):
         >>> ms.dtype_to_nptype(ms.int8)
         <class 'numpy.int8'>
     """
+    logger.warning("The interface 'mindspore.dtype_to_nptype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _dtype_to_nptype(type_)
+
+
+def _dtype_to_nptype(type_):
+    """
+    Convert MindSpore dtype to numpy data type.
+    """
     _dtype_nptype_dict = {
         bool_: np.bool_,
         int8: np.int8,
@@ -280,9 +318,12 @@ def dtype_to_nptype(type_):
         complex128: np.complex128,
     }
     if type_ == bfloat16:
-        if not np_version_valid(True):
-            raise TypeError("The Numpy bfloat16 data type is not supported now, please ensure that the current "
-                            "Numpy version is not less than the version when the mindspore is compiled.")
+        if not np_dtype_valid(True):
+            raise TypeError(
+                "The Numpy bfloat16 data type is not supported now, please ensure that the current "
+                "Numpy version is not less than the version when the mindspore is compiled, "
+                "and the major versions are same."
+            )
         return np_bfloat16
     return _dtype_nptype_dict[type_]
 
@@ -291,6 +332,9 @@ def dtype_to_pytype(type_):
     r"""
     Convert MindSpore dtype to python data type.
 
+    Note:
+        The interface is deprecated from version 2.7 and will be removed in a future version.
+
     Args:
         type\_ (:class:`mindspore.dtype`): MindSpore's dtype.
 
@@ -303,23 +347,31 @@ def dtype_to_pytype(type_):
         >>> print(out)
         <class 'bool'>
     """
+    logger.warning("The interface 'mindspore.dtype_to_pytype' is deprecated from version 2.7 "
+                   "and will be removed in a future version.")
+    return _dtype_to_pytype(type_)
 
+
+def _dtype_to_pytype(type_):
+    """
+    Convert MindSpore dtype to python data type.
+    """
     return {
-        bool_: bool,
-        int_: int,
-        int8: int,
-        int16: int,
-        int32: int,
-        int64: int,
-        uint8: int,
-        uint16: int,
-        uint32: int,
-        uint64: int,
-        float_: float,
-        float16: float,
-        float32: float,
-        float64: float,
-        bfloat16: float,
+        bool_: builtins.bool,
+        int_: builtins.int,
+        int8: builtins.int,
+        int16: builtins.int,
+        int32: builtins.int,
+        int64: builtins.int,
+        uint8: builtins.int,
+        uint16: builtins.int,
+        uint32: builtins.int,
+        uint64: builtins.int,
+        float_: builtins.float,
+        float16: builtins.float,
+        float32: builtins.float,
+        float64: builtins.float,
+        bfloat16: builtins.float,
         list_: list,
         tuple_: tuple,
         string: str,
@@ -335,7 +387,6 @@ def _issubclass_(type_, dtype):
     return typing.is_subclass(type_, dtype)
 
 
-
 def type_size_in_bytes(dtype):
     """
     Return type size in bytes.
@@ -407,7 +458,7 @@ class QuantDtype(enum.Enum):
     def __str__(self):
         return f"{self.name}"
 
-    def value(self) -> int:
+    def value(self) -> builtins.int:
         """
         Return value of `QuantDtype`. This interface is currently used to serialize or deserialize `QuantDtype`
         primarily.

mindspore/common/dump.py

@@ -25,15 +25,19 @@ def set_dump(target, enabled=True):
     Enable or disable dump for the `target` and its contents.
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when Synchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document
-    <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
+    Please note that this API takes effect only when the Dump function is enabled, and the `dump_mode`
+    field in the Dump configuration file is set to `"2"` with the `ms_backend` compilation backend
+    (please refer to the backend parameter in
+    `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_).
+    See the `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
     The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
     Note:
-        1. This API is only effective for GRAPH_MODE whose graph compilation level is O0/O1 with Ascend backend,
-           and can not work for fusion Primitive operators.
+        1. This API is only available for JIT compilation, requires 'Ascend' as the device_target and
+           `ms_backend` as the compilation backend (please refer to the backend parameter in
+           `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_),
+           and does not support fused operators.
         2. This API only supports being called before training starts.
            If you call this API during training, it may not be effective.
         3. After using `set_dump(Cell, True)` , operators in forward and backward
@@ -64,9 +68,8 @@ def set_dump(target, enabled=True):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, set_dump
+        >>> from mindspore import Tensor, set_dump, jit
         >>>
-        >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> ms.set_device(device_target="Ascend")
         >>>
         >>> class MyNet(nn.Cell):
@@ -75,6 +78,7 @@ def set_dump(target, enabled=True):
         ...         self.conv1 = nn.Conv2d(5, 6, 5, pad_mode='valid')
         ...         self.relu1 = nn.ReLU()
         ...
+        ...     @jit
         ...     def construct(self, x):
         ...         x = self.conv1(x)
         ...         x = self.relu1(x)
@@ -109,15 +113,6 @@ def set_dump(target, enabled=True):
              "If you have Ascend device, consider set device_target to Ascend "
              "before calling set_dump.".format(current_target))
 
-    current_mode = context.get_context("mode")
-    if current_mode != context.GRAPH_MODE:
-        # We will not return here in case user changed mode later.
-        warn(
-            "Current mode is PYNATIVE_MODE, which is not supported by set_dump. "
-            "Only GRAPH_MODE is supported currently. "
-            "Consider set mode to GRAPH_MODE "
-            "before calling set_dump.")
-
     # The actual set dump logic.
     if isinstance(target, nn.Cell):
         target.add_flags(dump=enabled)

mindspore/common/{auto_dynamic_shape.py → dynamic_shape/auto_dynamic_shape.py}

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2023 Huawei Technologies Co., Ltd
+# Copyright 2020-2025 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.
@@ -261,7 +261,12 @@ class _AutoIdentifyDynamicShape:
                 return False
         return True
 
-    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode):
+    @staticmethod
+    def _is_invalid_shape(shape):
+        """Check if input shape is valid"""
+        return is_shape_unknown(shape) or not shape
+
+    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode, enable_jit_dynamic=False):
         """is enable auto identify shape"""
         if not is_sink_mode and not args_list:
             return False
@@ -270,10 +275,12 @@ class _AutoIdentifyDynamicShape:
                 continue
             if not isinstance(elem, (list, tuple, Tensor, int, float)):
                 return False
-            if isinstance(elem, Tensor) and (is_shape_unknown(elem.shape) or (not elem.shape)):
+            if isinstance(elem, Tensor) and \
+                self._is_invalid_shape(elem.shape) and \
+                not enable_jit_dynamic:
                 return False
             if not is_sink_mode and isinstance(elem, (list, tuple)):
-                return self._is_enable_auto_dynamic_shape(elem, is_sink_mode)
+                return self._is_enable_auto_dynamic_shape(elem, is_sink_mode, enable_jit_dynamic)
         return True
 
     @staticmethod
@@ -328,10 +335,10 @@ class _AutoIdentifyDynamicShape:
         logger.info((f'generalize with generalize shape cache, compile args shape = {res_shape}'))
         return new_generalize_shape
 
-    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode):
+    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode, enable_jit_dynamic=False):
         """generate compile args in auto dynamic shape"""
         if not self.is_enable_auto_dynamic_shape or \
-            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode) or \
+            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode, enable_jit_dynamic) or \
             not self._check_input_number_and_type(args_list):
             self.is_enable_auto_dynamic_shape = False
             return args_list
@@ -475,11 +482,13 @@ class _AutoIdentifyDynamicShape:
 _auto_dynamic_shape = _AutoIdentifyDynamicShape()
 
 
-def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False):
+def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False, enable_jit_dynamic=False):
     """get auto dynamic shape args."""
     if key_id not in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id] = _AutoIdentifyDynamicShape(enable_auto_dynamic)
-    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(compile_args, False)
+    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(
+        compile_args, False, enable_jit_dynamic
+    )
     return compile_args
 
 
@@ -487,18 +496,3 @@ def update_auto_dynamic_shape_phase(compile_args, key_id, phase):
     """update auto dynamic shape phase."""
     if key_id in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)
-
-
-def get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id, input_signature,
-                                                           enable_auto_dynamic=False):
-    """get auto dynamic shape args."""
-    if input_signature is None:
-        return get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic)
-    return compile_args
-
-
-def update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, input_signature):
-    """update auto dynamic shape phase."""
-    if input_signature is None:
-        if key_id in auto_dynamic_shape_dict:
-            auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)

mindspore/common/dynamic_shape/enable_dynamic.py

@@ -0,0 +1,197 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2025 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.
+# ============================================================================
+"""Define enable_dynamic decorator."""
+import types
+import inspect
+from mindspore import log as logger
+from mindspore.common.tensor import Tensor
+from mindspore.common._utils import get_func, is_dim_unknown
+from mindspore.common.dynamic_shape.auto_dynamic_shape import SHAPE_DIM_ANY
+
+
+ENABLE_DYNAMIC = "__enable_dynamic__"
+
+
+def _check_element_valid(item, shape, name):
+    """Check elements in shape."""
+    if item is not SHAPE_DIM_ANY and (isinstance(item, int) and item <= 0):
+        raise TypeError(f"The argument '{name}' has invalid shape '{shape}', only supports None " \
+                        f"or a tuple/list of positive integers and None.")
+    return True
+
+
+def _check_arg_shape_valid(arg, name):
+    """Check if the shape of arg is valid"""
+    #if the shape of arg is None
+    if isinstance(arg, Tensor) and is_dim_unknown(arg.shape):
+        return True
+    if isinstance(arg, Tensor) and \
+        SHAPE_DIM_ANY in arg.shape and \
+        all(_check_element_valid(item, arg.shape, name) for item in arg.shape):
+        return True
+    if isinstance(arg, (tuple, list)) and any(_check_arg_shape_valid(item, name) for item in arg):
+        return True
+    return False
+
+
+def _check_arg_type_valid(arg, name):
+    """Check if the type of arg is valid."""
+    if isinstance(arg, Tensor):
+        return
+    if isinstance(arg, (tuple, list)):
+        for item in arg:
+            _check_arg_type_valid(item, name)
+    else:
+        raise TypeError(f"The decorator enable_dynamic only supports Tensor " \
+                        f"or a tuple/list of Tensor, but the argument : {name} is type of:{type(arg)}.")
+
+
+def _check_input_valid(arg):
+    """Check if real argument is valid."""
+    if isinstance(arg, Tensor):
+        if not all(isinstance(item, int) and item > 0 for item in arg.shape):
+            raise ValueError(f"When using decorator enable_dynamic, the corresponding shape of inputs should be " \
+                             f"a tuple/list of positive integers")
+    elif isinstance(arg, (tuple, list)):
+        for item in arg:
+            _check_input_valid(item)
+    else:
+        raise TypeError(f"When using decorator enable_dynamic, the corresponding inputs only supports Tensor " \
+                    f"or a tuple/list of Tensor.")
+
+
+def _check_arg_type_shape(arg, dyn_arg, name):
+    """Check the type, shape and dtype of real argument."""
+    if isinstance(arg, Tensor) and isinstance(dyn_arg, Tensor):
+        if arg.dtype != dyn_arg.dtype:
+            raise TypeError(f"When using decorator enable_dynamic, input tensor dtype = {arg.dtype}, " \
+                            f"dynamic tensor dtype = {dyn_arg.dtype}, tensor dtypes are not the same.")
+        if is_dim_unknown(dyn_arg.shape):
+            return
+        if len(arg.shape) != len(dyn_arg.shape) or \
+            any(y is not SHAPE_DIM_ANY and x != y for x, y in zip(arg.shape, dyn_arg.shape)):
+            raise ValueError(f"When using decorator enable_dynamic, input tensor shape = {arg.shape}, " \
+                             f"dynamic tensor shape = {dyn_arg.shape}, tensor shapes are not the same.")
+    elif isinstance(arg, (tuple, list)) and isinstance(dyn_arg, (tuple, list)):
+        if len(arg) != len(dyn_arg):
+            raise ValueError("Input sequences must have the same structure and length.")
+        for x, y in zip(arg, dyn_arg):
+            _check_arg_type_shape(x, y, name)
+    else:
+        raise TypeError(f"When using decorator enable_dynamic, the type between argument '{name}' " \
+                        f"and corresponding input are not the same.")
+
+
+def generate_dynamic_sequence_args(args_list, dyn_args_list):
+    """Generate dynamic shapes for input sequence"""
+    if isinstance(args_list, Tensor):
+        return dyn_args_list if args_list.shape != dyn_args_list.shape else args_list
+    result = []
+    for x, y in zip(args_list, dyn_args_list):
+        result.append(generate_dynamic_sequence_args(x, y))
+    return type(args_list)(result)
+
+
+def generate_dynamic_tensor_args(args_list, dynamic_shapes):
+    """Generate compile args with dynamic_shapes"""
+    new_compile_args = list(args_list)
+    for index, arg in enumerate(args_list):
+        if isinstance(arg, (tuple, list)) and not hasattr(arg, "__ms_mutable__"):
+            raise ValueError(f"When using decorator enable_dynamic, the corresponding attribute of input should be " \
+                             f"mutable(tuple/list)")
+        if index not in dynamic_shapes:
+            continue
+        _check_input_valid(arg)
+        name, dyn_arg = dynamic_shapes[index]
+        _check_arg_type_shape(arg, dyn_arg, name)
+        new_compile_args[index] = generate_dynamic_sequence_args(arg, dyn_arg)
+    logger.debug(f"args_list: {args_list}, dynamic_shapes: {dynamic_shapes}, " \
+                 f"new_compile_args: {new_compile_args}")
+    return new_compile_args
+
+
+def enable_dynamic(**kwargs):
+    """
+    Use to specify whether the shape of the parameter is dynamic shape or dynamic rank.
+
+    Note:
+        - It needs to be used in conjunction with the JIT interface. Without using the JIT decorator,
+          the dynamic shape and dynamic rank functions will not be enabled.
+        - In the scenario where both set_context(mode=GRAPH_MODE) and nn.Cell are set simultaneously,
+          use enabled_dynamic to report an error.
+
+    Args:
+        kwargs (dict): The input types are Tensor, tuple[Tensor] and list[Tensor]. If one or
+            more dimensions in the shape of the parameter need to be specified as dynamic shapes,
+            the corresponding dimensions in the shape can be set to None. If the shape that needs
+            to generate specified parameters is dynamic rank, the shape can be set to None.
+
+    Returns:
+        Function, return a function that specifies the dynamic shape information of the parameter.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
+        >>> from mindspore import enable_dynamic
+        >>> from mindspore import jit
+        ...
+        >>> x = Tensor(np.random.randn(2, 3), ms.float32)
+        >>> y = Tensor(np.random.randn(2, 3), ms.float32)
+        ...
+        >>> # Specify parameter y as dynamic shape
+        >>> @enable_dynamic(y=Tensor(shape=None, dtype=ms.float32))
+        >>> @jit
+        >>> def func(x, y):
+        ...     return x + 1, y + 1
+        ...
+        >>> out = func(x, y)
+    """
+    # Check inputs at first.
+    if not kwargs:
+        raise ValueError(f"When using decorator enable_dynamic, the input cannot be empty!")
+    for name, arg in kwargs.items():
+        _check_arg_type_valid(arg, name)
+        if not _check_arg_shape_valid(arg, name):
+            raise TypeError(f"When using decorator enable_dynamic, the shape of argument '{name}' " \
+                            f"at least have one None.")
+
+    def decorator(func):
+        if not isinstance(func, (types.FunctionType, types.MethodType)):
+            raise ValueError(f"Decorator enable_dynamic can only be used for function or method " \
+                             f"decrocated by ms.jit, but got {func}.")
+        signature = inspect.signature(func)
+        sigs_name = [sig_name for sig_name in signature.parameters if sig_name != "self"]
+        if len(kwargs) > len(sigs_name):
+            raise ValueError(f"When using decorator enable_dynamic, the number of arguments {len(kwargs)} " \
+                             f"exceeds the number of function arguments {len(sigs_name)}.")
+        # Generate dynamic args.
+        dynamic_args = dict()
+        for key, value in kwargs.items():
+            index = sigs_name.index(key)
+            if index in dynamic_args:
+                raise ValueError(f"keyword argument repeated: {key}")
+            dynamic_args[index] = (key, value)
+        # Set dynamic_tensor_shape to func.
+        inner_func = inspect.unwrap(func, stop=lambda f: not hasattr(f, '__wrapped__'))
+        setattr(get_func(inner_func), ENABLE_DYNAMIC, dynamic_args)
+        logger.info(f"Set enable dynamic: {dynamic_args} to {inner_func}")
+        return func
+    return decorator