mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/experimental/optim/lr_scheduler.py

@@ -41,10 +41,11 @@ class LRScheduler:
 
     Args:
         optimizer (:class:`mindspore.experimental.optim.Optimizer`): The optimizer instance.
-        last_epoch (int, optional): The index of the last epoch. Default: ``-1``.
+        last_epoch (int, optional): The number of times the `step()` method of
+            the current learning rate adjustment strategy has been executed. Default: ``-1``.
 
     Raises:
-        TypeError: If `optimizer` is not an Optimizer.
+        TypeError: If `optimizer` does not satisfy the type requirement.
         KeyError: If `last_epoch` != -1 and ``'initial_lr'`` not in param groups.
         ValueError: if `last_epoch` is not int.
         ValueError: If `last_epoch` is not greater than -1.
@@ -700,9 +701,8 @@ class ConstantLR(LRScheduler):
 @jit_class
 class SequentialLR:
     r"""
-    Receives the list of schedulers that is expected to be called sequentially during
-    optimization process and milestone points that provides exact intervals to reflect
-    which scheduler is supposed to be called at a given epoch.
+    Concatenate multiple learning rate adjustment strategies in `schedulers` in sequence,
+    switching to the next learning rate adjustment strategy at `milestone`.
 
     .. warning::
         This is an experimental lr scheduler module that is subject to change.
@@ -713,8 +713,10 @@ class SequentialLR:
         optimizer (:class:`mindspore.experimental.optim.Optimizer`): Wrapped optimizer.
         schedulers (list[:class:`mindspore.experimental.optim.lr_scheduler.LRScheduler`]):
             List of learning rate schedulers.
-        milestones (list): List of integers that reflects milestone points.
-        last_epoch (int, optional): The index of the last epoch. Default: ``-1``.
+        milestones (list): List of integers of milestone points,
+            sets which learning rate adjustment strategy is invoked for each epoch.
+        last_epoch (int, optional): The number of times the `step()` method
+            of the current learning rate adjustment strategy has been executed. Default: ``-1``.
 
     Raises:
         ValueError: The optimizer in `schedulers` is different from the `optimizer` passed in.
@@ -805,9 +807,8 @@ class ReduceLROnPlateau:
     """
     Reduce learning rate when a metric has stopped improving.
     Models often benefit from reducing the learning rate by a factor
-    of 2-10 once learning stagnates. This scheduler reads a metrics
-    quantity and if no improvement is seen for a 'patience' number
-    of epochs, the learning rate is reduced.
+    of 2-10 once learning stagnates. The scheduler reads the metrics `metrics` during execution
+    and adjusts the learning rate via the `step` method if the metrics do not improve within `patience` cycles.
 
     .. warning::
         This is an experimental lr scheduler module that is subject to change.
@@ -816,7 +817,8 @@ class ReduceLROnPlateau:
 
     Args:
         optimizer (:class:`mindspore.experimental.optim.Optimizer`): Wrapped optimizer.
-        mode (str, optional): One of `min`, `max`. In `min` mode, lr will
+        mode (str, optional): Trigger mode that triggers a reduction in learning rate
+            when the monitoring metrics are at their `min` / `max` point. In `min` mode, lr will
             be reduced when the quantity monitored has stopped
             decreasing; in `max` mode it will be reduced when the
             quantity monitored has stopped increasing. Default: ``'min'``.
@@ -830,12 +832,25 @@ class ReduceLROnPlateau:
             Default: ``10``.
         threshold (float, optional): Threshold for measuring the new optimum,
             to only focus on significant changes. Default: ``1e-4``.
-        threshold_mode (str, optional): One of `rel`, `abs`. Given dynamic_threshold is the benchmark to
-            define whether the current metric is improvement,
-            in ``'rel'`` mode, dynamic_threshold = best * ( 1 + threshold ) in ``'max'`` mode
-            or best * ( 1 - threshold ) in ``'min'`` mode.
-            In ``'abs'`` mode, dynamic_threshold = best + threshold in ``'max'`` mode or
-            best - threshold in ``'min'`` mode. Default: ``'rel'``.
+        threshold_mode (str, optional): A mode for measuring indicators of change for the better.
+            One of `rel`, `abs`. Default: ``'rel'``.
+
+            Assume that `best` represents the best value of the current performance metric.
+
+            - In ``'rel'`` mode, the indicator is compared to a `threshold` in proportional form:
+
+              - When `mode` is ``'max'``, the indicator is considered better if it exceeds best * ( 1 + threshold ).
+
+              - When `mode` is ``'min'``, the indicator is considered better
+                if it is lower than best * ( 1 - threshold ).
+
+            - In ``'abs'`` mode, the indicator is compared to `threshold` in absolute value form:
+
+              - When `mode` is ``'max'``, the indicator is considered better if it exceeds best + threshold.
+
+              - When `mode` is ``'min'``, the indicator is considered better
+                if it is lower than best - threshold.
+
         cooldown (int, optional): Number of epochs to wait before resuming
             normal operation after lr has been reduced. Default: ``0``.
         min_lr (Union(float, list), optional): A scalar or a list of scalars. A
@@ -1164,15 +1179,17 @@ class CyclicLR(LRScheduler):
 class CosineAnnealingWarmRestarts(LRScheduler):
     r"""
     Set the learning rate of each parameter group using a cosine annealing warm restarts
-    schedule. Where :math:`\eta_{max}` is set to the initial lr, :math:`\eta_{min}` is the minimum value
-    for learning rate, :math:`\eta_{t}` is the current learning rate, :math:`T_{0}` is the number of iterations for the
-    first restar, :math:`T_{i}` is the current number of iterations between two warm restarts in SGDR,
-    :math:`T_{cur}` is the number of epochs since the last restart in SGDR.
+    schedule.
 
     .. math::
         \eta_t = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 +
         \cos\left(\frac{T_{cur}}{T_{i}}\pi\right)\right)
 
+    Where :math:`\eta_{max}` is set to the initial lr, :math:`\eta_{min}` is the minimum value
+    for learning rate, :math:`\eta_{t}` is the current learning rate, :math:`T_{0}` is the number of iterations for the
+    first restar, :math:`T_{i}` is the current number of iterations between two warm restarts in SGDR,
+    :math:`T_{cur}` is the number of epochs since the last restart in SGDR.
+
     When :math:`T_{cur}=T_{i}`, set :math:`\eta_t = \eta_{min}`.
     When :math:`T_{cur}=0` after restart, set :math:`\eta_t=\eta_{max}`.
 
@@ -1189,7 +1206,8 @@ class CosineAnnealingWarmRestarts(LRScheduler):
         T_0 (int): Number of iterations for the first restart.
         T_mult (int, optional): A factor increases :math:`T_{i}` after a restart. Default: ``1``.
         eta_min (Union(float, int), optional): Minimum learning rate. Default: ``0``.
-        last_epoch (int, optional): The index of the last epoch. Default: ``-1``.
+        last_epoch (int, optional): The number of times the `step()` method of
+            the current learning rate adjustment strategy has been executed. Default: ``-1``.
 
     Raises:
         ValueError: `T_0` is less than or equal than 0 or not an int.

mindspore/experimental/optim/radam.py

@@ -56,7 +56,7 @@ class RAdam(Optimizer):
 
     .. math::
         \begin{align*}
-            &\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)}, \:
@@ -67,7 +67,7 @@ class RAdam(Optimizer):
                     v_0 \leftarrow 0 \text{ (second moment)} \\
                     \rho_{\infty} \xleftarrow{\text{def}} \dfrac{2}{1 - \beta_2} - 1
                 \end{cases} \\
-            &\rule{110mm}{0.4pt} \\
+            &\rule{180mm}{0.4pt} \\
             &\textbf{For } t = 1 \text{ to } \ldots \text{ do}: \\
             &\quad g_t \leftarrow \nabla_{\theta} f_t(\theta_{t - 1}) \\
             &\quad \text{If } \lambda \neq 0: \\
@@ -84,9 +84,9 @@ class RAdam(Optimizer):
             &\quad\quad \theta_t \leftarrow \theta_{t - 1} - \gamma \widehat{m_t} r_t l_t \\
             &\quad \text{Else}: \\
             &\quad\quad \theta_t \leftarrow \theta_{t - 1} - \gamma \widehat{m_t} \\
-            &\rule{110mm}{0.4pt} \\
+            &\rule{180mm}{0.4pt} \\
             &\bf{Return}: \theta_t \\
-            &\rule{110mm}{0.4pt}
+            &\rule{180mm}{0.4pt}
         \end{align*}
 
     .. warning::
@@ -157,7 +157,7 @@ class RAdam(Optimizer):
         self.increase_tensor = Tensor(1, mstype.int32)
         self.assignadd = P.AssignAdd()
 
-    @jit
+    @jit(backend="ms_backend")
     def implementation(self, lr, beta1, beta2, weight_decay, eps, start_id, end_id, gradients):
         """Extract the common computing part for acceleration"""
         params = self.parameters[start_id: end_id]

mindspore/experimental/optim/rprop.py

@@ -133,7 +133,7 @@ class Rprop(Optimizer):
         self.increase_tensor = Tensor(1, mstype.int32)
         self.op_cast = P.Cast()
 
-    @jit
+    @jit(backend="ms_backend")
     def implementation(self, etaminus, etaplus, group_id, lr, gradients, maximize, step_size_min, step_size_max):
         """Extract the common computing part for acceleration"""
         etaminus, etaplus = op_cast(etaminus, mstype.float32), op_cast(etaplus, mstype.float32)

mindspore/experimental/optim/sgd.py

@@ -51,7 +51,7 @@ class SGD(Optimizer):
 
     To be noticed, for the first step, :math:`v_{t+1} = gradient`.
 
-    Here : where p, v and u denote the parameters, accum, and momentum respectively.
+    Here: where :math:`p`, :math:`v` and :math:`u` denote the parameters, accum, and momentum respectively.
 
     .. warning::
         This is an experimental optimizer API that is subject to change.

mindspore/hal/contiguous_tensors_handle.py

@@ -19,7 +19,7 @@ from mindspore.common.tensor import Tensor
 from mindspore.common.api import _convert_python_data
 from mindspore.common.dtype import type_size_in_bytes
 from mindspore._c_expression import slice_by_tensor_index, slice_by_padding_shape, \
-    combine_tensor_list_contiguous as combine_tensor_list, Tensor as Tensor_
+    combine_tensor_list_contiguous as combine_tensor_list, TensorPy as Tensor_
 
 
 def combine_tensor_list_contiguous(tensor_list, enable_mem_align=True):
@@ -29,7 +29,7 @@ def combine_tensor_list_contiguous(tensor_list, enable_mem_align=True):
     Args:
         tensor_list (list[Tensor], Tuple[Tensor]): The tensor list to be stored.
         enable_mem_align (bool, optional): Whether to enable the memory alignment function.
-            False is not supported. Default: ``True`` .
+            False is not supported. Default ``True`` .
 
     Returns:
             ContiguousTensorsHandle, a manager with contiguous memory.
@@ -59,7 +59,7 @@ class ContiguousTensorsHandle:
     Args:
         tensor_list (list[Tensor], Tuple[Tensor]): The tensor list to be stored.
         enable_mem_align (bool, optional): Whether to enable the memory alignment function.
-            False is not supported. Default: ``True`` .
+            False is not supported. Default ``True`` .
 
     Returns:
         ContiguousTensorsHandle, a manager with contiguous memory.
@@ -137,15 +137,11 @@ class ContiguousTensorsHandle:
         Return the tensor which is sliced by tensor index.
 
         Args:
-            start(int, None): Starting position. Default：``None``.
-            end(int, None): Deadline position. Default：``None``.
+            start(int, None): Starting position. Default ``None``.
+            end(int, None): Deadline position. Default ``None``.
 
         Returns:
-            Tensor，is sliced by tensor index.
-
-        Raises:
-            TypeError: If `start` or `end`, is neither an 'int' nor a 'none'.
-            ValueError: If values of `start` or `end` are negative, or out of the list range, or start >= end.
+            Tensor
 
         Examples:
             >>> import numpy as np

mindspore/hal/device.py

@@ -120,23 +120,21 @@ def _check_device_id(fn):
 
 def is_initialized(device_target):
     """
-    Returns whether specified backend is initialized.
+    Return whether specified device is initialized, this api will be deprecated and removed in future versions.
 
     Note:
-        - The api will be deprecated.
+        MindSpore's devices "CPU", "GPU" and "Ascend" will be initialized in the following scenarios:
 
-    Note:
-        MindSpore's backends "CPU", "GPU" and "Ascend" will be initialized in the following scenarios:
-
-        - For distributed job, backend will be initialized after `mindspore.communication.init` method is called.
-        - For standalone job, backend will be initialized after running
+        - For distributed job, device will be initialized after `mindspore.communication.init` method is called.
+        - For standalone job, device will be initialized after running
           the first operator or calling creating stream/event interfaces.
 
     Args:
-        device_target (str): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` .
 
     Returns:
-        Bool, whether the specified backend is initialized.
+        bool
 
     Examples:
         >>> import mindspore as ms
@@ -162,25 +160,21 @@ def is_initialized(device_target):
 
 def is_available(device_target):
     """
-    Returns whether specified backend is available.
-    All dependent libraries should be successfully loaded if this backend is available.
-
-    Note:
-        - The api will be deprecated.
-        - CPU hardware, please use the interface :func:`mindspore.device_context.cpu.is_available`.
-        - GPU hardware, please use the interface :func:`mindspore.device_context.gpu.is_available`.
-        - Ascend hardware, please use the interface :func:`mindspore.device_context.ascend.is_available`.
+    Return whether specified device is available, this api will be deprecated and removed in future versions, please
+    use the api :func:`mindspore.device_context.cpu.is_available` , :func:`mindspore.device_context.gpu.is_available`,
+    :func:`mindspore.device_context.ascend.is_available` instead.
 
     Args:
-        device_target (str): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
-        Bool, whether the specified backend is available for this MindSpore package.
+        bool
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.is_available(device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.is_available(device_target))
         True
     """
     if device_target not in valid_targets:
@@ -201,29 +195,24 @@ def is_available(device_target):
 @_check_inputs_validation
 def device_count(device_target=None):
     """
-    Returns device count of specified backend.
+    Return device count of specified device, this api will be deprecated and removed in future versions, please use
+    the api :func:`mindspore.device_context.cpu.device_count` , :func:`mindspore.device_context.gpu.device_count`,
+    :func:`mindspore.device_context.ascend.device_count` instead.
 
     Note:
-        - The api will be deprecated.
-        - CPU hardware, please use the interface :func:`mindspore.device_context.cpu.device_count`.
-        - GPU hardware, please use the interface :func:`mindspore.device_context.gpu.device_count`.
-        - Ascend hardware, please use the interface :func:`mindspore.device_context.ascend.device_count`.
-
-
-    Note:
-        If `device_target` is not specified, get the device count of the current backend set by context.
-        For CPU backend, this method always returns 1.
+        For CPU device, this method always returns 1.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
-        int.
+        int
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.device_count(device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.device_count(device_target))
     """
     hal_instance = hal_instances.get(device_target)
     if hal_instance is None:
@@ -235,20 +224,15 @@ def device_count(device_target=None):
 @_check_inputs_validation
 def get_device_capability(device_id, device_target=None):
     """
-    Get specified device's capability.
-
-    Note:
-        - The api will be deprecated.
-
-    Note:
-        If `device_target` is not specified, get the device capability of the current backend set by context.
+    Get specified device's capability, this api will be deprecated and removed in future versions.
 
     Args:
         device_id (int): The device id of which the capability will be returned.
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str, optional):  The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
-        tuple(int, int) for GPU.
+        tuple(param1, param2) for GPU.
 
         - param1 - int, cuda major revision number.
         - param2 - int, cuda minor revision number.
@@ -256,9 +240,9 @@ def get_device_capability(device_id, device_target=None):
         None for Ascend and CPU.
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.get_device_capability(0, device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.get_device_capability(0, device_target))
     """
     hal_instance = hal_instances.get(device_target)
     if hal_instance is None:
@@ -270,20 +254,17 @@ def get_device_capability(device_id, device_target=None):
 @_check_inputs_validation
 def get_device_properties(device_id, device_target=None):
     """
-    Get specified device's properties.
-
-    Note:
-        - The api will be deprecated.
+    Get specified device's properties, this api will be deprecated and removed in future versions.
 
     Note:
-        If `device_target` is not specified, get the device properties of the current backend set by context.
-        For Ascend, backend must be initialized before calling this method,
+        For Ascend, device must be initialized before calling this method,
         or `total_memory` and `free_memory` will be 0,
         and `device_id` will be ignored since this method only returns current device's properties.
 
     Args:
         device_id (int): The device id of which the properties will be returned.
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         - `cudaDeviceProp` for GPU.
@@ -314,9 +295,9 @@ def get_device_properties(device_id, device_target=None):
         - None for CPU.
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.get_device_properties(0, device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.get_device_properties(0, device_target))
     """
     hal_instance = hal_instances.get(device_target)
     if hal_instance is None:
@@ -328,26 +309,23 @@ def get_device_properties(device_id, device_target=None):
 @_check_inputs_validation
 def get_device_name(device_id, device_target=None):
     """
-    Get specified device's name.
-
-    Note:
-        - The api will be deprecated.
+    Get specified device's name, this api will be deprecated and removed in future versions.
 
     Note:
-        If `device_target` is not specified, get the device name of the current backend set by context.
-        This method always returns "CPU" for CPU backend.
+        This method always returns "CPU" for CPU device.
 
     Args:
         device_id (int): The device id of which the name will be returned.
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
-        str.
+        str
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.get_device_name(0, device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.get_device_name(0, device_target))
     """
     hal_instance = hal_instances.get(device_target)
     if hal_instance is None:
@@ -358,25 +336,21 @@ def get_device_name(device_id, device_target=None):
 @_check_inputs_validation
 def get_arch_list(device_target=None):
     """
-    Get the architecture list this MindSpore was compiled for.
-
-    Note:
-        - The api will be deprecated.
-
-    Note:
-        If `device_target` is not specified, get the device name of the current backend set by context.
+    Get the architecture list this MindSpore was compiled for, this api will be deprecated and removed in future
+    versions.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         str for GPU.
         None for Ascend and CPU.
 
     Examples:
-        >>> import mindspore as ms
-        >>> device_target = ms.context.get_context("device_target")
-        >>> print(ms.hal.get_arch_list(device_target))
+        >>> import mindspore
+        >>> device_target = mindspore.context.get_context("device_target")
+        >>> print(mindspore.hal.get_arch_list(device_target))
     """
     hal_instance = hal_instances.get(device_target)
     if hal_instance is None: