mindspore 2.5.0__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/dataset/vision/utils.py

@@ -495,7 +495,7 @@ def get_image_num_channels(image):
 
     Raises:
         RuntimeError: If the dimension of `image` is less than 2.
-        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+        TypeError: If `image` is not of type numpy.ndarray or PIL Image.
 
     Examples:
         >>> import mindspore.dataset.vision as vision
@@ -528,7 +528,7 @@ def get_image_size(image):
 
     Raises:
         RuntimeError: If the dimension of `image` is less than 2.
-        TypeError: If `image` is not of type <class 'numpy.ndarray'> or <class 'PIL.Image.Image'>.
+        TypeError: If `image` is not of type type numpy.ndarray or PIL Image.
 
     Examples:
         >>> import mindspore.dataset.vision as vision
@@ -635,10 +635,12 @@ def read_video(filename, start_pts=0, end_pts=None, pts_unit="pts"):
 
     Args:
         filename(str): The path to the video file to be read.
-        start_pts(Union[float, Fraction, int], optional): The start presentation timestamp of the video. Default: 0.
-        end_pts(Union[float, Fraction, int], optional): The end presentation timestamp of the video. Default: None.
+        start_pts(Union[float, Fraction, int], optional): The start presentation timestamp of the video.
+            Default: ``0``.
+        end_pts(Union[float, Fraction, int], optional): The end presentation timestamp of the video.
+            Default: ``None``.
             The None is represented by 2147483647.
-        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: "pts".
+        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: ``"pts"``.
 
     Returns:
         - numpy.ndarray, four dimensions uint8 data for video. The format is [T, H, W, C]. `T` is the number of frames,

mindspore/device_context/ascend/op_debug.py

@@ -35,7 +35,7 @@ def execute_timeout(op_timeout):
     Args:
         op_timeout (int): Set the maximum duration of executing an operator in seconds.
           If the execution time exceeds this value, system will terminate the task.
-          0 means endless wait. The defaults for AI Core and AICPU operators vary on different hardware.
+          0 means endless wait. The defaults for AI Core and AI CPU operators vary on different hardware.
 
     Examples:
         >>> import mindspore as ms
@@ -92,3 +92,62 @@ def debug_option(option_value):
             f"to 'oom' currently, but got {option_value}."
         )
     AscendOpDebugConf.get_instance().set_debug_option(option_value)
+
+
+def aclinit_config(config):
+    """
+    Configure the configuration items for the aclInit interface.
+    please refer to `Ascend Community document about aclInit.
+    <https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/800alpha003/apiref/appdevgapi/aclcppdevg_03_0022.html>`_.
+
+    Args:
+        config(dict): When initializing AscendCL, you can enable or configure the
+            following features through this configuration interface.
+
+            - ``"max_opqueue_num"``: When executing using the single-operator model method, to save memory and balance
+              the performance of calls, you can configure the maximum length of the single-operator model mapping
+              queue through the max_opqueue_num parameter. If the length reaches the maximum, the system will first
+              delete the mapping information that has not been used for a long time and the cached single-operator
+              model, and then load the latest mapping information and the corresponding single-operator model.
+              If the maximum length of the mapping queue is not configured, the default maximum length is 20,000.
+            - ``"err_msg_mode"``: This parameter is used to control the level at which error information is retrieved,
+              either by process or by thread. The default level is by process. "0" indicating that error information
+              is retrieved by thread.
+              "1" is the default value, indicates that error information is retrieved by process.
+            - ``"dump"``: This parameter is used to enable exception dump for Ascend operators. The value can be set to
+              {"dump_scene": "lite_exception"}, {"dump_scene": "lite_exception:disable"}.
+              {"dump_scene": "lite_exception"} indicates that the exception dump is enabled.
+              {"dump_scene": "lite_exception:disable"} indicates that the exception dump is disabled.
+              {"dump_scene": "lite_exception"} is the default value, indicates that the exception dump is enabled.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 0)
+        >>> ms.device_context.ascend.op_debug.aclinit_config({"max_opqueue_num": "20000", "err_msg_mode": "1",
+        ...                                                   "dump": {"dump_scene": "lite_exception"}})
+    """
+    aclinit_cfg_modes = {
+        "max_opqueue_num": (str,),
+        "err_msg_mode": ['0', '1'],
+        "dump": [{"dump_scene": "lite_exception"}, {"dump_scene": "lite_exception:disable"}],
+    }
+    instance = AscendOpDebugConf.get_instance()
+    aclinit_cfg_setters = {
+        "max_opqueue_num": instance.set_max_opqueue_num,
+        "err_msg_mode": instance.set_err_msg_mode,
+        "dump": instance.set_lite_exception_dump
+    }
+    aclinit_cfg_set = tuple(aclinit_cfg_modes.keys())
+    for key, value in config.items():
+        if key not in aclinit_cfg_set:
+            raise ValueError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the key must be one of "
+                             f"{aclinit_cfg_set}, but got {key}.")
+        supported_modes = aclinit_cfg_modes.get(key)
+        if isinstance(supported_modes, list) and value not in supported_modes:
+            raise ValueError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the value of argument {key} "
+                             f"must be one of {supported_modes}, but got {value}.")
+        if isinstance(supported_modes, tuple) and not isinstance(value, supported_modes):
+            raise TypeError(f"For 'ms.device_context.ascend.op_debug.aclinit_config', the type of argument {key} "
+                            f"must be one of {supported_modes}, but got {type(value)}.")
+        cfg_setter = aclinit_cfg_setters.get(key)
+        cfg_setter(value)

mindspore/device_context/ascend/op_tuning.py

@@ -61,8 +61,6 @@ def op_compile(value):
 def aoe_tune_mode(tune_mode):
     """
     AOE tuning mode setting, which is not set by default.
-    For detailed information, please refer to `Ascend Optimization Enging
-    <https://www.mindspore.cn/docs/en/master/model_train/optimize/aoe.html>`_ .
 
     Args:
         tune_mode (str): AOE tuning mode setting.
@@ -97,8 +95,6 @@ def aoe_job_type(config):
     Set the parameters specific to Ascend Optimization Engine.It needs to be used in
     conjunction with mindspore.device_context.op_tuning.aoe_tune_mode(tune_mode).
     The framework set to "2" by default.
-    For detailed information, please refer to `Ascend Optimization Enging
-    <https://www.mindspore.cn/docs/en/master/model_train/optimize/aoe.html>`_ .
 
     Args:
         config (str): Choose the tuning type.

mindspore/device_manager.py

@@ -21,7 +21,24 @@ from mindspore._c_expression import DeviceManagerConf, DeviceContextManager, MSC
 from mindspore._checkparam import args_type_check
 from mindspore.parallel._ps_context import _need_reset_device_target_for_ps
 
-__all__ = ['set_device', 'set_deterministic']
+
+__all__ = ['set_device', 'set_deterministic', 'get_current_device']
+
+
+class DeviceInfo(tuple):
+    """
+    DeviceInfo class. Store the current device target and the corresponding device id.
+    """
+    def __new__(cls, device_target, device_id):
+        return super().__new__(cls, (device_target, device_id))
+
+    @property
+    def device_target(self):
+        return self[0]
+
+    @property
+    def device_id(self):
+        return self[1]
 
 
 @args_type_check(device_target=str, device_id=int)
@@ -35,13 +52,13 @@ def set_device(device_target, device_id=None):
 
     Args:
         device_target (str): The target device to run, only support "Ascend", "GPU", and "CPU".
-        device_id (int): ID of the target device, the value must be in [0, device_num_per_host-1].
+        device_id (int, optional): ID of the target device, the value must be in [0, device_num_per_host-1],
+            where device_num_per_host refers to the total number of devices on the host. Default: ``None`` .
             The frame will set different default behaviours according to the scenario:
             if it is a single-card scenario, the frame will be set to 0.
             In a distributed scenario where msrun is started, the framework will
             automatically negotiate the available device_id values.
             In a distributed scenario with other startup methods, the frame is set to 0.
-            "device_num_per_host" refers to the total number of devices on the host.
 
     Examples:
         >>> import mindspore as ms
@@ -79,6 +96,25 @@ def set_device(device_target, device_id=None):
     DeviceManagerConf.get_instance().set_device(device_target, device_id, is_default)
 
 
+def get_current_device():
+    """
+    Get device target and device id in the current running environment.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.get_current_device()
+        ('Ascend', 1)
+        >>> ms.get_current_device().device_target
+        'Ascend'
+        >>> ms.get_current_device().device_id
+        1
+    """
+    device_target = DeviceManagerConf.get_instance().get_device_target()
+    device_id = DeviceManagerConf.get_instance().get_device_id()
+    return DeviceInfo(device_target, device_id)
+
+
 @args_type_check(deterministic=bool)
 def set_deterministic(deterministic):
     """

mindspore/experimental/es/embedding_service.py

@@ -125,18 +125,20 @@ class EmbeddingServiceOut:
 
 class EmbeddingService:
     r"""
-    Currently, ES(EmbeddingService) feature can only create one object which can support model training and inference
+    ES(EmbeddingService) feature can support model training and inference
     for PS embedding and data_parallel embedding, and provide unified embedding management, storage,
     and computing capabilities for training and inference.
     PS embedding refer to tables that vocab_size more than 100,000, and recommended to store them on the
     Parameter Server (PS). Data_parallel embedding refer to tables that vocab_size less than 100,000, and recommended
     to store them on device.
 
+    Currently, ES feature can only create one instance of EmbeddingService object.
+
     .. warning::
         This is an experimental EmbeddingService API that is subject to change.
 
     .. note::
-        This API needs to call 'mindspore.communication.init()' before,
+        This API needs to call :func:`mindspore.communication.init` before,
         and it can take effect after the dynamic networking is completed.
 
     Raises:
@@ -241,24 +243,26 @@ class EmbeddingService:
             name (str): The embedding table name.
             init_vocabulary_size (int): The size of embedding table.
             embedding_dim (int): The embedding dim of data in embedding table.
-            max_feature_count (int): The count of keys when look up for PS.
-            initializer (Initializer): The initialization strategy for the PS embedding, default is ``Uniform``.
-            embedding_type (str): The embedding type, configurable parameters ["PS", "data_parallel"],
+            max_feature_count (int, optional): The count of keys when look up for PS. Default: ``None``.
+            initializer (Initializer, optional): The initialization strategy for the PS embedding,
+                default is ``Uniform(scale=0.01)``.
+            embedding_type (str, optional): The embedding type, configurable parameters ["PS", "data_parallel"],
                 ``"PS"`` means initializing PS embedding, ``"data_parallel"`` means initializing data_parallel
                 embedding, and default is ``"PS"``.
-            ev_option (EmbeddingVariableOption): Properties of the PS embedding,
+            ev_option (EmbeddingVariableOption, optional): Properties of the PS embedding,
                 is a EmbeddingVariableOption obj which returned by embedding_variable_option function.
                 Default is ``None``.
-            multihot_lens (int): The param only use when allow_merge is enabled, and not support now.
+            multihot_lens (int, optional): The param only use when `allow_merge` is enabled, and not support now.
                 Default is ``None``.
-            optimizer (str): The type of optimizer in the train mode for PS embedding,
+            optimizer (str, optional): The type of optimizer in the train mode for PS embedding,
                 cannot be shared among each PS embedding, and currently only ``"Adam"``, ``"Ftrl"``, ``"SGD"`` and
                 ``"RMSProp"`` are supported, and default is ``None``.
-            allow_merge (bool): Whether to enable merge data_parallel embeddings, currently only be False,
+            allow_merge (bool, optional): Whether to enable merge data_parallel embeddings, currently only be False,
                 and default is ``False``.
-            optimizer_param (float): The "initialize accumulator value" param of optimizer which configured by user,
+            optimizer_param (float, optional): The "initialize accumulator value" param
+                of optimizer which configured by user,
                 representing the init value of moment accumulator, and default is ``None``.
-            mode (str): Run mode, configurable parameters ["train", "predict", "export"],
+            mode (str, optional): Run mode, configurable parameters ["train", "predict", "export"],
                 ``"train"`` means train mode, ``"predict"`` means predict mode, ``"export"`` mean export mode,
                 and default is ``"train"``.
 
@@ -345,8 +349,9 @@ class EmbeddingService:
 
         Args:
             padding_key (int): The value for padding key, must be a genuine and legal hash key.
-            mask (bool): Whether to update padding key. If set to false, it will not be updated. Default is ``True``.
-            mask_zero (bool): Whether to update padding key when key is 0. Default is ``False``.
+            mask (bool, optional): Whether to update padding key. If set to false, it will not be updated.
+                Default is ``True``.
+            mask_zero (bool, optional): Whether to update padding key when key is 0. Default is ``False``.
 
         Returns:
             PaddingParamsOption object.
@@ -368,7 +373,7 @@ class EmbeddingService:
 
         Args:
             completion_key (int): The value for completion key.
-            mask (bool): Whether to update completion key. If set to false, it will not be updated,
+            mask (bool, optional): Whether to update completion key. If set to false, it will not be updated,
                 and default is ``True``.
 
         Returns:
@@ -396,10 +401,11 @@ class EmbeddingService:
 
         Args:
             filter_freq (int): The frequency threshold value for feature admission.
-            default_key (int): The key that number of occurrences does not reach the threshold,
-                return value of default key as the corresponding value when look up embedding, and default is ``None``.
-            default_value (int/float): The key that number of occurrences does not reach the threshold,
-                return default value which length value is embedding dim, and default is ``None``.
+            default_key (int, optional): The key that number of occurrences does not reach the threshold,
+                return value of `default_key` as the corresponding value when look up embedding,
+                and default is ``None``.
+            default_value (Union[int, float], optional): The key that number of occurrences does not
+                reach the threshold, return default value which length value is embedding dim, and default is ``None``.
 
         Returns:
             CounterFilter object.
@@ -460,16 +466,17 @@ class EmbeddingService:
         Set variable option for PS embedding.
 
         Args:
-            filter_option (CounterFilter): The option of counter filter. Default is ``None``.
-            padding_option (PaddingParamsOption): The option of padding key. Default is ``None``.
-            evict_option (EvictOption): The option evict. Default is ``None``.
-            completion_option (CompletionKeyOption): The option of completion key. Default is ``None``.
-            storage_option (None): Reserved option, currently not supported. Default is ``None``.
-            feature_freezing_option (None): Reserved option, currently not supported. Default is ``None``.
-            communication_option (None): Reserved option, currently not supported. Default is ``None``.
+            filter_option (CounterFilter, optional): The option of counter filter. Default is ``None``.
+            padding_option (PaddingParamsOption, optional): The option of padding key. Default is ``None``.
+            evict_option (EvictOption, optional): The option evict. Default is ``None``.
+            completion_option (CompletionKeyOption, optional): The option of completion key. Default is ``None``.
+            storage_option (None, optional): Reserved option, currently not supported. Default is ``None``.
+            feature_freezing_option (None, optional): Reserved option, currently not supported. Default is ``None``.
+            communication_option (None, optional): Reserved option, currently not supported. Default is ``None``.
 
         Returns:
-            EmbeddingVariableOption object, used as the ev_option parameter for embedding_init.
+            EmbeddingVariableOption object, used as the ev_option parameter for
+            :func:`mindspore.experimental.es.EmbeddingService.embedding_init` .
 
         Raises:
             TypeError: If value of "filter_option" is not None and the type of "filter_option" is not CounterFilter.
@@ -501,7 +508,8 @@ class EmbeddingService:
 
         .. note::
             This function can only be executed by rank 0.
-            Need to call embedding_variable_option to set evict_option for each PS embedding before export.
+            Need to call :func:`mindspore.experimental.es.EmbeddingService.embedding_variable_option`
+            to set evict_option for each PS embedding before export.
 
         Args:
             file_path (str): The path to export embedding ckpt, and the last character cannot be ``"/"``.

mindspore/experimental/map_parameter.py

@@ -23,7 +23,7 @@ from copy import copy
 import numbers
 import mindspore as ms
 from mindspore.common.parameter import Parameter, _get_unique_parameter_key
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import MapTensor_
 from mindspore.ops.operations import _map_tensor_ops
 
@@ -78,12 +78,12 @@ class MapParameter(Parameter):
         if value_dtype is not None:
             if isinstance(value_shape, numbers.Number):
                 value_shape = (value_shape,)
-            data = Tensor_(value_dtype, value_shape)
+            data = Tensor_(dtype=value_dtype, shape=value_shape)
         elif value_tensor is not None:
-            data = Tensor_(value_tensor.dtype, value_tensor.shape)
+            data = Tensor_(dtype=value_tensor.dtype, shape=value_tensor.shape)
         else:
             # default
-            data = Tensor_(ms.float32, (1,))
+            data = Tensor_(dtype=ms.float32, shape=(1,))
         obj = Tensor_.__new__(cls)
         Tensor_.__init__(obj, data)
         # Compatible attributes with Parameter.

mindspore/experimental/optim/adadelta.py

@@ -37,32 +37,28 @@ class Adadelta(Optimizer):
     Implements Adadelta algorithm.
 
     .. math::
-        \newcommand{\grad}[2]{\nabla_{#1} f_{#2}(#2_{#2 - 1})}
-        \newcommand{\updateVar}[3]{#1_{#2} \leftarrow #1_{#2 - 1} \rho + #3_{#2} (1 - \rho)}
-
-        \begin{align*}
-            &\rule{150mm}{0.4pt} \\
-            &\textbf{Input}:
-                \gamma \text{ (lr)}, \: \theta_0 \text{ (params)}, \: f(\theta) \text{ (objective)},
-                \: \rho \text{ (decay)}, \: \lambda \text{ (weight decay)} \\
-            &\textbf{Initialize}:
-                \begin{cases}
-                    v_0 \leftarrow 0 \text{ (square avg)} \\
-                    u_0 \leftarrow 0 \text{ (accumulate variables)}
-                \end{cases} \\
-            &\rule{110mm}{0.4pt} \\
-            &\textbf{For } t = 1 \text{ to } \ldots \text{ do}: \\
-            &\quad g_t \leftarrow \grad{\theta}{t} \\
-            &\quad \text{If } \lambda \neq 0: \\
-            &\quad\quad g_t \leftarrow g_t + \lambda \theta_{t - 1} \\
-            &\quad v_t \leftarrow \updateVar{v}{t}{g^2} \\
-            &\quad \Delta x_t \leftarrow \frac{\sqrt{u_{t - 1} + \epsilon}}{\sqrt{v_t + \epsilon}} g_t \\
-            &\quad u_t \leftarrow \updateVar{u}{t}{\Delta x^2} \\
-            &\quad \theta_t \leftarrow \theta_{t - 1} - \gamma \Delta x_t \\
-            &\rule{110mm}{0.4pt} \\
-            &\bf{Return}: \theta_t \\
-            &\rule{110mm}{0.4pt}
-        \end{align*}
+        \begin{aligned}
+            &\rule{180mm}{0.4pt}                                                                 \\
+            &\textbf{input}      : \gamma \text{ (lr)}, \: \theta_0 \text{ (params)},
+                \: f(\theta) \text{ (objective)}, \: \rho \text{ (decay)},
+                \: \lambda \text{ (weight decay)}                                                \\
+            &\textbf{initialize} :  v_0  \leftarrow 0 \: \text{ (square avg)},
+                \: u_0 \leftarrow 0 \: \text{ (accumulate variables)}                     \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                                 \\
+            &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
+            &\hspace{5mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \\
+            &\hspace{5mm}if \: \lambda \neq 0                                                    \\
+            &\hspace{10mm} g_t \leftarrow g_t + \lambda  \theta_{t-1}                            \\
+            &\hspace{5mm} v_t      \leftarrow v_{t-1} \rho + g^2_t (1 - \rho)                    \\
+            &\hspace{5mm}\Delta x_t    \leftarrow   \frac{\sqrt{u_{t-1} +
+                \epsilon }}{ \sqrt{v_t + \epsilon}  }g_t \hspace{21mm}                           \\
+            &\hspace{5mm} u_t  \leftarrow   u_{t-1}  \rho +
+                 \Delta x^2_t  (1 - \rho)                                                        \\
+            &\hspace{5mm}\theta_t      \leftarrow   \theta_{t-1} - \gamma  \Delta x_t            \\
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
+            &\bf{return} \:  \theta_t                                                     \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
+        \end{aligned}
 
     .. warning::
         This is an experimental optimizer API that is subject to change.

mindspore/experimental/optim/adagrad.py

@@ -38,12 +38,12 @@ class Adagrad(Optimizer):
 
     .. math::
        \begin{aligned}
-            &\rule{110mm}{0.4pt}                                                                 \\
+            &\rule{160mm}{0.4pt}                                                                 \\
             &\textbf{input}      : \gamma \text{ (lr)}, \: \theta_0 \text{ (params)}, \: f(\theta)
                 \text{ (objective)}, \: \lambda \text{ (weight decay)},                          \\
             &\hspace{12mm}    \tau \text{ (initial accumulator value)}, \: \eta\text{ (lr decay)}\\
             &\textbf{initialize} :  state\_sum_0 \leftarrow 0                             \\[-1.ex]
-            &\rule{110mm}{0.4pt}                                                                 \\
+            &\rule{160mm}{0.4pt}                                                                 \\
             &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
             &\hspace{5mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \\
             &\hspace{5mm} \tilde{\gamma}    \leftarrow \gamma / (1 +(t-1) \eta)                  \\
@@ -52,9 +52,9 @@ class Adagrad(Optimizer):
             &\hspace{5mm}state\_sum_t  \leftarrow  state\_sum_{t-1} + g^2_t                      \\
             &\hspace{5mm}\theta_t \leftarrow
                 \theta_{t-1}- \tilde{\gamma} \frac{g_t}{\sqrt{state\_sum_t}+\epsilon}            \\
-            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
+            &\rule{160mm}{0.4pt}                                                          \\[-1.ex]
             &\bf{return} \:  \theta_t                                                     \\[-1.ex]
-            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
+            &\rule{160mm}{0.4pt}                                                          \\[-1.ex]
        \end{aligned}
 
     .. warning::

mindspore/experimental/optim/adam.py

@@ -49,12 +49,14 @@ class Adam(Optimizer):
 
     .. math::
         \begin{aligned}
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{input}      : \gamma \text{ (lr)}, \beta_1, \beta_2
                 \text{ (betas)},\theta_0 \text{ (params)},f(\theta) \text{ (objective)}          \\
             &\hspace{13mm}      \lambda \text{ (weight decay)},  \: \textit{amsgrad},
                 \:\textit{maximize}                                                              \\
             &\textbf{initialize} :  m_0 \leftarrow 0 \text{ ( first moment)},
                 v_0\leftarrow 0 \text{ (second moment)},\: \widehat{v_0}^{max}\leftarrow 0\\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
             &\hspace{5mm}\textbf{if} \: \textit{maximize}:                                       \\
             &\hspace{10mm}g_t           \leftarrow   -\nabla_{\theta} f_t (\theta_{t-1})         \\
@@ -74,7 +76,9 @@ class Adam(Optimizer):
             &\hspace{5mm}\textbf{else}                                                           \\
             &\hspace{10mm}\theta_t \leftarrow \theta_{t-1} - \gamma \widehat{m_t}/
                 \big(\sqrt{\widehat{v_t}} + \epsilon \big)                                       \\
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
             &\bf{return} \:  \theta_t                                                     \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
        \end{aligned}
 
     .. warning::

mindspore/experimental/optim/adamax.py

@@ -43,14 +43,14 @@ class Adamax(Optimizer):
 
     .. math::
        \begin{aligned}
-            &\rule{110mm}{0.4pt}                                                                 \\
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{input}      : \gamma \text{ (lr)}, \beta_1, \beta_2
                 \text{ (betas)},\theta_0 \text{ (params)},f(\theta) \text{ (objective)},
                 \: \lambda \text{ (weight decay)},                                                \\
             &\hspace{13mm}    \epsilon \text{ (epsilon)}                                          \\
             &\textbf{initialize} :  m_0 \leftarrow 0 \text{ ( first moment)},
                 u_0 \leftarrow 0 \text{ ( infinity norm)}                                 \\[-1.ex]
-            &\rule{110mm}{0.4pt}                                                                 \\
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
             &\hspace{5mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \\
             &\hspace{5mm}if \: \lambda \neq 0                                                    \\
@@ -58,9 +58,9 @@ class Adamax(Optimizer):
             &\hspace{5mm}m_t      \leftarrow   \beta_1 m_{t-1} + (1 - \beta_1) g_t               \\
             &\hspace{5mm}u_t      \leftarrow   \mathrm{max}(\beta_2 u_{t-1}, |g_{t}|+\epsilon)   \\
             &\hspace{5mm}\theta_t \leftarrow \theta_{t-1} - \frac{\gamma m_t}{(1-\beta^t_1) u_t} \\
-            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
             &\bf{return} \:  \theta_t                                                     \\[-1.ex]
-            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
        \end{aligned}
 
     .. warning::

mindspore/experimental/optim/adamw.py

@@ -97,6 +97,7 @@ class AdamW(Optimizer):
 
     .. math::
         \begin{aligned}
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{input}      : \gamma \text{(lr)}, \: \beta_1, \beta_2
                 \text{(betas)}, \: \theta_0 \text{(params)}, \: f(\theta) \text{(objective)},
                 \: \epsilon \text{ (epsilon)}                                                    \\
@@ -104,6 +105,7 @@ class AdamW(Optimizer):
                 \: \textit{maximize}                                                             \\
             &\textbf{initialize} : m_0 \leftarrow 0 \text{ (first moment)}, v_0 \leftarrow 0
                 \text{ ( second moment)}, \: \widehat{v_0}^{max}\leftarrow 0              \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                                 \\
             &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
             &\hspace{5mm}\textbf{if} \: \textit{maximize}:                                       \\
             &\hspace{10mm}g_t           \leftarrow   -\nabla_{\theta} f_t (\theta_{t-1})          \\
@@ -122,7 +124,9 @@ class AdamW(Optimizer):
             &\hspace{5mm}\textbf{else}                                                           \\
             &\hspace{10mm}\theta_t \leftarrow \theta_t - \gamma \widehat{m_t}/
                 \big(\sqrt{\widehat{v_t}} + \epsilon \big)                                       \\
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
             &\bf{return} \:  \theta_t                                                     \\[-1.ex]
+            &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
        \end{aligned}
 
     .. warning::

mindspore/experimental/optim/asgd.py

@@ -124,7 +124,7 @@ class ASGD(Optimizer):
         self.assignadd = P.AssignAdd()
         self.op_cast = P.Cast()
 
-    @jit
+    @jit(backend="ms_backend")
     def implementation(self, lambd, alpha, t0, lr, group_id, maximize, gradients, weight_decay):
         """Extract the common computing part for acceleration"""
         start_id = self.group_start_id[group_id]