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

mindspore/dataset/core/config.py

@@ -1097,12 +1097,12 @@ def get_error_samples_mode():
     return _CDE_TO_PYTHON_ERROR_SAMPLES_MODE.get(_config.get_error_samples_mode())
 
 
-def set_iterator_mode(do_copy=True, parallel_convert=False):
+def set_iterator_mode(do_copy=False, parallel_convert=False):
     """
     Select dataset iterator optimization strategy.
 
     Args:
-        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "True".
+        do_copy (bool): Whether dataset iterator creates a Tensor from numpy.ndarray without copy. Default: "False".
         parallel_convert (bool): Whether dataset iterator starts a thread to organize Tensors to output.
             Default: "False".
 
@@ -1122,7 +1122,7 @@ def set_iterator_mode(do_copy=True, parallel_convert=False):
 def get_iterator_mode():
     """
     Get dataset iterator mode indicate iterator optimization strategy.
-    If `set_iterator_mode` is never called before, `do_copy` default to "True", `parallel_convert` default to "False".
+    If `set_iterator_mode` is never called before, `do_copy` default to "False", `parallel_convert` default to "False".
 
     Returns:
         dict, iterator mode dictionary contains the value of `do_copy` and `parallel_convert`.

mindspore/dataset/engine/datasets.py

@@ -575,6 +575,12 @@ class Dataset:
                     create shared memory, and represents ``output_columns`` use the second element as the
                     unit to create shared memory.
 
+        .. warning::
+            `batch` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize
+            `per_batch_map`, which is known to be insecure. It is possible to construct malicious pickle data
+            which will execute arbitrary code during unpickling. Never load data that could have come from
+            untrusted sources, or has been tampered with.
+
         Returns:
             Dataset, a new dataset with the above operation applied.
 
@@ -886,6 +892,12 @@ class Dataset:
 
                 - offload (bool, optional): Flag to indicate whether offload is used. Default: ``None``.
 
+        .. warning::
+            `map` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize `operations`,
+            which is known to be insecure. It is possible to construct malicious pickle data which will
+            execute arbitrary code during unpickling. Never load data that could have come from untrusted sources,
+            or has been tampered with.
+
         Note:
             - Input `operations` accepts TensorOperations defined in mindspore.dataset part, plus user-defined
               Python functions (PyFuncs).
@@ -1557,7 +1569,7 @@ class Dataset:
         del api_tree
 
     @check_tuple_iterator
-    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         """
         Create an iterator over the dataset that yields samples of type list, whose elements are
         the data for each column.
@@ -1571,7 +1583,7 @@ class Dataset:
                 convert it to Tensor. Default: ``False`` .
             do_copy (bool, optional): Whether to copy the data when converting output to Tensor,
                 or reuse the buffer for better performance, only works when `output_numpy` is ``False`` .
-                Default: ``True`` .
+                Default: ``False`` .
 
         Returns:
             Iterator, a dataset iterator that yields samples of type list.
@@ -1598,7 +1610,7 @@ class Dataset:
         return TupleIterator(self, columns, num_epochs, output_numpy, do_copy)
 
     @check_dict_iterator
-    def create_dict_iterator(self, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_dict_iterator(self, num_epochs=-1, output_numpy=False, do_copy=False):
         """
         Create an iterator over the dataset that yields samples of type dict,
         while the key is the column name and the value is the data.
@@ -1610,7 +1622,7 @@ class Dataset:
                 convert it to Tensor. Default: ``False`` .
             do_copy (bool, optional): Whether to copy the data when converting output to Tensor,
                 or reuse the buffer for better performance, only works when `output_numpy` is ``False`` .
-                Default: ``True`` .
+                Default: ``False`` .
 
         Returns:
             Iterator, a dataset iterator that yields samples of type dict.
@@ -3632,9 +3644,10 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
                         "process(es): {}".format(self.cleaning_process.pid, self.get_pids()))
 
             if get_enable_watchdog():
-                worker_ids = [worker.pid for worker in self.workers]
+                worker_ids = [os.getpid()]
+                worker_ids.extend([worker.pid for worker in self.workers])
                 worker_ids.append(self.cleaning_process.pid)
-                cde.register_worker_pids(id(self), set(worker_ids))
+                cde.register_worker_pids(id(self), worker_ids)
 
     def _abort_monitor(self):
         """Deregister workers monitored by the watch dog and join clean process."""
@@ -4385,7 +4398,7 @@ class TransferDataset(Dataset):
     def create_dict_iterator(self, num_epochs=-1, output_numpy=False):
         raise RuntimeError("TransferDataset is not iterable.")
 
-    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         raise RuntimeError("TransferDataset is not iterable.")
 
     def __iter__(self):

mindspore/dataset/engine/datasets_user_defined.py

@@ -220,6 +220,7 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
 
         self.ppid = os.getpid()
         self.pids = []
+        self.thread_ids = []
         self.check_interval = get_multiprocessing_timeout_interval()  # the interval of check queue's size
 
         if self.multi_process is True:
@@ -277,12 +278,32 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                 worker = _GeneratorWorkerMt(self.dataset, self.eof, worker_id)
                 worker.daemon = True
                 self.need_join = True
+                worker.start()
+                self.thread_ids.append(worker.ident)
                 self.workers.append(worker)
 
         # Register a termination function using weakref to avoid the object from unable to properly destruct.
         atexit.register(lambda cleanup: cleanup()() if cleanup() is not None else None,
                         weakref.WeakMethod(self.terminate))
 
+    def get_worker_ids(self):
+        """
+        Get dict of worker's ids
+
+        Returns:
+            dict of strings
+        """
+        if not self.is_mp_enabled():
+            return {}
+        worker_ids = {}
+        if self.multi_process is True:
+            worker_ids["is_thread"] = False
+            worker_ids["worker_id"] = self.pids
+        else:
+            worker_ids["is_thread"] = True
+            worker_ids["worker_id"] = self.thread_ids
+        return worker_ids
+
     def terminate(self):
         self._stop_subprocess()
 
@@ -421,9 +442,10 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                     "process(es): {}".format(self.cleaning_process.pid, [worker.pid for worker in self.workers]))
 
         if get_enable_watchdog():
-            worker_ids = [worker.pid for worker in self.workers]
+            worker_ids = [os.getpid()]
+            worker_ids.extend([worker.pid for worker in self.workers])
             worker_ids.append(self.cleaning_process.pid)
-            cde.register_worker_pids(id(self), set(worker_ids))
+            cde.register_worker_pids(id(self), worker_ids)
 
     def _release_fd(self):
         """Release the file descriptor by subprocess"""
@@ -480,6 +502,8 @@ class SamplerFn(cde.PythonMultiprocessingRuntime):
                     except Exception:  # pylint: disable=W0703
                         # Block all errors when join
                         continue
+                elif not self.multi_process:
+                    w.join(timeout=5)
 
             if self.multi_process is True:
                 self._release_fd()
@@ -795,6 +819,12 @@ class GeneratorDataset(MappableDataset, UnionBaseDataset):
         - `Load & Process Data With Dataset Pipeline
           <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/dataset_gallery.html>`_
 
+    .. warning::
+        `GeneratorDataset` uses `dill` module implicitly in multiprocessing `spawn` mode to serialize/deserialize
+        `source`, which is known to be insecure. It is possible to construct malicious pickle data which will
+        execute arbitrary code during unpickling. Never load data that could have come from untrusted sources,
+        or has been tampered with.
+
     Note:
         - If you configure `python_multiprocessing=True` (Default: ``True`` ) and `num_parallel_workers>1`
           (default: ``1`` ) indicates that the multiprocessing mode is started for data load acceleration.

mindspore/dataset/engine/iterators.py

@@ -220,7 +220,7 @@ class Iterator:
         dataset: Dataset to be iterated over
     """
 
-    def __init__(self, dataset, num_epochs=-1, output_numpy=False, do_copy=True):
+    def __init__(self, dataset, num_epochs=-1, output_numpy=False, do_copy=False):
         self._col_names = None
 
         # create a copy of tree and work on it.
@@ -493,7 +493,7 @@ class TupleIterator(Iterator):
     The derived class of Iterator with list type.
     """
 
-    def __init__(self, dataset, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
+    def __init__(self, dataset, columns=None, num_epochs=-1, output_numpy=False, do_copy=False):
         if columns is not None:
             if not isinstance(columns, list):
                 columns = [columns]

mindspore/dataset/engine/obs/config_loader.py

@@ -57,12 +57,12 @@ class _Config:
 
     def _convert_type(self, key):
         if key not in self.config:
-            return  os.environ[key]
+            return os.environ[key]
         if isinstance(self.config[key], int):
             return int(os.environ[key])
         if isinstance(self.config[key], float):
             return float(os.environ[key])
-        return  os.environ[key]
+        return os.environ[key]
 
 
 config = _Config()

mindspore/dataset/engine/obs/obs_mindrecord_dataset.py

@@ -506,3 +506,11 @@ class MindRecordFromOBS:
         path = os.path.join(self._local_path, target_dataset)
         _iteration = MindDataset(dataset_files=[path], shuffle=False)
         return _iteration.get_col_names()
+
+    def close(self):
+        if self._pool:
+            self._pool.terminate()
+            self._pool = None
+
+    def __del__(self):
+        self.close()

mindspore/dataset/transforms/py_transforms.py

@@ -51,10 +51,14 @@ class PyTensorOperation:
         if "transforms" in json_obj.keys():
             # operations which have transforms as input, need to call _from_json() for each transform to deseriallize
             transforms = []
+            valid_module = ['mindspore.dataset.vision', 'mindspore.dataset.text',
+                            'mindspore.dataset.audio', 'mindspore.dataset.transforms']
             for json_op in json_obj["transforms"]:
-                transforms.append(getattr(
-                    sys.modules.get(json_op.get("python_module")),
-                    json_op.get("tensor_op_name")).from_json(json.dumps(json_op.get("tensor_op_params"))))
+                py_module = sys.modules.get(json_op.get("python_module"))
+                if py_module.__package__ not in valid_module:
+                    raise RuntimeError('Invalid json content, try to serialzie dataset again.')
+                transforms.append(getattr(py_module, json_op.get("tensor_op_name")).from_json(
+                    json.dumps(json_op.get("tensor_op_params"))))
             new_op.transforms = transforms
         if "output_type" in json_obj.keys():
             output_type = np.dtype(json_obj["output_type"])

mindspore/dataset/transforms/transforms.py

@@ -165,10 +165,14 @@ class PyTensorOperation:
         if "transforms" in json_obj.keys():
             # operations which have transforms as input, need to call _from_json() for each transform to deseriallize
             transforms = []
+            valid_module = ['mindspore.dataset.vision', 'mindspore.dataset.text',
+                            'mindspore.dataset.audio', 'mindspore.dataset.transforms']
             for json_op in json_obj["transforms"]:
-                transforms.append(getattr(
-                    sys.modules.get(json_op.get("python_module")),
-                    json_op["tensor_op_name"]).from_json(json.dumps(json_op["tensor_op_params"])))
+                py_module = sys.modules.get(json_op.get("python_module"))
+                if py_module.__package__ not in valid_module:
+                    raise RuntimeError('Invalid json content, try to serialzie dataset again.')
+                transforms.append(getattr(py_module, json_op["tensor_op_name"]).from_json(
+                    json.dumps(json_op["tensor_op_params"])))
             new_op.transforms = transforms
         if "output_type" in json_obj.keys():
             output_type = np.dtype(json_obj["output_type"])

mindspore/dataset/vision/validators.py

@@ -351,6 +351,7 @@ def check_resize_interpolation(method):
 
     return new_method
 
+
 def check_device_target(method):
     """A wrapper that wraps a parameter checker"""
 

mindspore/device_context/ascend/device.py

@@ -66,7 +66,7 @@ def is_available():
 
 def _is_supported():
     device_target = ms.context.get_context("device_target")
-    if device_target == 'CPU' or device_target == 'GPU':
+    if device_target in ['CPU', 'GPU']:
         logger.error(f"{device_target} device is not supported. Please use correct device")
         return False
     return True

mindspore/device_context/gpu/__init__.py

@@ -14,8 +14,8 @@
 # ============================================================================
 """init file for GPU device context"""
 
+__all__ = ['device_count', 'is_available']
+
 from .device import device_count, is_available
 from .op_precision import *
 from .op_tuning import *
-
-__all__ = ["device_count", "is_available"]

mindspore/device_context/gpu/device.py

@@ -64,7 +64,7 @@ def is_available():
 
 def _is_supported():
     device_target = ms.context.get_context("device_target")
-    if device_target == 'CPU' or device_target == 'Ascend':
+    if device_target in ['CPU', 'Ascend']:
         logger.error(f"{device_target} device is not supported. Please use correct device")
         return False
     return True

mindspore/device_context/gpu/op_precision.py

@@ -29,7 +29,8 @@ function_status = {'matmul_allow_tf32': False, 'conv_allow_tf32': False}
 def matmul_allow_tf32(value):
     """
     Whether to convert FP32 to TF32 for Matmul operators.
-    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32 <https://docs.nvidia.com/cuda/cublas/index.html>`_.
+    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32
+    <https://docs.nvidia.com/cuda/cublas/index.html>`_.
 
     Args:
         value (bool): Whether to convert FP32 to TF32 for Matmul operators. If not configured, the framework
@@ -50,7 +51,8 @@ def matmul_allow_tf32(value):
 def conv_allow_tf32(value):
     """
     Whether to convert FP32 to TF32 for Conv operators.
-    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32 <https://docs.nvidia.com/cuda/cublas/index.html>`_.
+    For detailed information, please refer to `CUBLAS_COMPUTE_32F_FAST_TF32
+    <https://docs.nvidia.com/cuda/cublas/index.html>`_.
 
     Args:
         value (bool): Whether to convert FP32 to HF32 for Conv operators. If not configured, the framework defaults

mindspore/device_context/gpu/op_tuning.py

@@ -27,7 +27,8 @@ function_status = {'conv_fprop_algo': False, 'conv_wgrad_algo': False, 'conv_dgr
 def conv_fprop_algo(mode):
     """
     Specifies convolution forward algorithm.
-    For detailed information, please refer to `NVIDA cuDNN about cudnnConvolutionForward <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+    For detailed information, please refer to `NVIDA cuDNN about cudnnConvolutionForward
+    <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
 
     Args:
         mode (str): convolution forward algorithm. If not configured, the framework defaults to 'normal'.
@@ -80,7 +81,8 @@ def conv_fprop_algo(mode):
 def conv_wgrad_algo(mode):
     """
     Specifies convolution filter grad algorithm.
-    For detailed information, please refer to `NVIDA cuDNN <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+    For detailed information, please refer to `NVIDA cuDNN
+    <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
 
     Args:
         mode (str): convolution filter grad algorithm. If not configured, the framework defaults to 'normal'.
@@ -129,7 +131,8 @@ def conv_wgrad_algo(mode):
 def conv_dgrad_algo(mode):
     """
     Specifies convolution data grad algorithm.
-    For detailed information, please refer to `NVIDA cuDNN <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
+    For detailed information, please refer to `NVIDA cuDNN
+    <https://docs.nvidia.com/deeplearning/cudnn/latest/api/cudnn-cnn-library.html>`_.
 
     Args:
         mode (str): convolution data grad algorithm. If not configured, the framework defaults to 'normal'.

mindspore/device_manager.py

@@ -15,16 +15,14 @@
 
 """Device manager interfaces."""
 
+__all__ = ['set_device', 'set_deterministic', 'get_current_device']
+
 import os
 from mindspore import log as logger
 from mindspore._c_expression import DeviceManagerConf, DeviceContextManager, MSContext, CollectiveManager
 from mindspore._checkparam import args_type_check
 from mindspore.parallel._ps_context import _need_reset_device_target_for_ps
 
-
-__all__ = ['set_device', 'set_deterministic', 'get_current_device']
-
-
 class DeviceInfo(tuple):
     """
     DeviceInfo class. Store the current device target and the corresponding device id.
@@ -120,14 +118,21 @@ def set_deterministic(deterministic):
     """
     Enables or disables deterministic computing.
 
-    When deterministic computing is enabled, the same output is generated if an operator is executed
-    for multiple times with the same hardware and input.This often slows down operator execution.
-    In distributed scenario, we suggest user to set deterministic mode before
-    calling :func:`mindspore.communication.init` to enable deterministic operation for
-    communication operators in the global communication group.
+    This configuration is a global configuration, and once enabled, subsequent calculation operations
+    will follow the configuration setting. When deterministic computing is enabled, the same output
+    is generated if an operator is executed for multiple times with the same hardware and input. This often
+    slows down operator execution.
 
     The framework not enabled deterministic computation by default.
 
+    Note:
+        - In distributed scenario, we suggest user to set deterministic computing before
+          calling :func:`mindspore.communication.init` to enable deterministic operation for
+          communication operators in the global communication group.
+        - The fixed method for deterministic calculation must be in the same main process as the network,
+          operator, etc. Only one deterministic state can be set in the same thread, and it is not recommended
+          to set deterministic state multiple times in one thread.
+
     Args:
         deterministic (bool): Whether to enable deterministic computing.
 
@@ -139,6 +144,8 @@ def set_deterministic(deterministic):
     if DeviceManagerConf.get_instance().is_deterministic_configured():
         raise RuntimeError("The 'mindspore.set_deterministic' can not be set repeatedly.")
 
+    logger.info(f"Set deterministic setting to '{deterministic}'.")
+
     # Must wait for all async created groups to be initialized so that
     # deterministic feature could be consistent between all processes.
     CollectiveManager.get_instance().wait_all_comm_init()

mindspore/experimental/llm_boost/ascend_native/llama_boost_ascend_native.py

@@ -19,7 +19,6 @@ import numpy as np
 from mindspore.common import Tensor, dtype
 from mindspore.experimental.llm_boost.ascend_native.llm_boost import LLMBoost
 
-
 def RoundUp(val: int, align: int) -> int:
     if align == 0:
         return 0
@@ -43,7 +42,6 @@ def ConvertTensor(nd_mat: np.ndarray, transpose: bool = True, nd2nz: bool = True
     nz_mat = nz_mat.reshape(r, c)
     return nz_mat
 
-
 class LlamaBoostAscendNative(LLMBoost):
     r"""
     Implements an Llama model in a single kernel.
@@ -66,7 +64,7 @@ class LlamaBoostAscendNative(LLMBoost):
     def _prepare_single_layer(self, ckpt, config, id):
         """ prepares the dictionary of weights of a single layer """
         prefix = 'model.layers.' + str(id)
-        is_last = (id == config.num_layers-1)
+        is_last = id == config.num_layers-1
         layer = 'layers.' + str(id) + '.'
         l_dict = {key: value for key, value in ckpt.items() if layer in key}
         if config.n_kv_heads is None:
@@ -94,8 +92,8 @@ class LlamaBoostAscendNative(LLMBoost):
         else:
             raise RuntimeError("hidden size and ffn hidden size must be divided by rank size without remainder.  \
                                 hidden_size: ", hid_size, " ffn_hidden_size: ", ffn_hid, " rank_size: ", rank_size)
-        quant = (self._get_from_dict(l_dict, "_weight_quantizer") is not None)
-        unite_qkv = (config.num_heads == config.n_kv_heads)
+        quant = self._get_from_dict(l_dict, "_weight_quantizer") is not None
+        unite_qkv = config.num_heads == config.n_kv_heads
         self.dictionary[prefix + ".attention_norm.weight"] = \
             Tensor(self._get_from_dict(l_dict, "attention_norm"), dtype=dtype.float16)
         self.dictionary[prefix + ".ffn_norm.weight"] = \

mindspore/experimental/llm_boost/atb/boost_base.py

@@ -18,7 +18,6 @@ import numpy as np
 import mindspore as ms
 from mindspore import ops, Tensor
 from mindspore import log as logger
-from mindspore.ops import operations as P
 import mindspore.common.dtype as mstype
 from mindspore._c_expression import _set_format
 from mindspore.common.parameter import Parameter
@@ -95,8 +94,8 @@ class AtbBoostBase:
             self.max_base_len, dtype=self.dtype, need_nz=self.need_nz
         )
 
-        self.cast = P.Cast()
-        self.reshape = P.Reshape()
+        self.cast = ops.Cast()
+        self.reshape = ops.Reshape()
         self.kv_quant = None
         self.rank_id = get_real_rank()
         self.device_num = get_real_group_size()

mindspore/experimental/optim/adadelta.py

@@ -1,34 +1,24 @@
-# 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.
+# The code implementation refers to the following files from pytorch:
+# - https://github.com/pytorch/pytorch/blob/v1.13.0/torch/optim/adadelta.py
+# Additional modifications are made by Huawei Technologies Co., Ltd in 2023.
 # ============================================================================
 """adadelta"""
 from __future__ import absolute_import
 
-from mindspore.ops import functional as F, composite as C, operations as P
+from mindspore import ops
 import mindspore.common.dtype as mstype
 from mindspore.experimental.optim.optimizer import Optimizer, check_not_less_than, check_not_less_than_without_equal
 from mindspore import _checkparam as validator
 from mindspore import jit
 
-_adadelta_opt = C.MultitypeFuncGraph("adadelta_opt")
+_adadelta_opt = ops.MultitypeFuncGraph("adadelta_opt")
 
 
 @_adadelta_opt.register("Function", "Number", "Number", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor")
 def _tensor_run_opt(opt, rho, epsilon, learning_rate, weight, accum, accum_update, gradient):
     """Apply adadelta optimizer to the weight parameter."""
     success = True
-    success = F.depend(success, opt(weight, accum, accum_update, learning_rate, rho, epsilon, gradient))
+    success = ops.depend(success, opt(weight, accum, accum_update, learning_rate, rho, epsilon, gradient))
     return success
 
 
@@ -60,6 +50,9 @@ class Adadelta(Optimizer):
             &\rule{180mm}{0.4pt}                                                          \\[-1.ex]
         \end{aligned}
 
+    For more details about Adadelta algorithm, please refer to `ADADELTA: An Adaptive Learning Rate Method
+    <https://arxiv.org/abs/1212.5701>`_.
+
     .. warning::
         This is an experimental optimizer API that is subject to change.
         This module must be used with lr scheduler module in `LRScheduler Class
@@ -129,18 +122,18 @@ class Adadelta(Optimizer):
 
         self.accum = self.parameters.clone(prefix="accum", init=0)
         self.accum_update = self.parameters.clone(prefix="accum_update", init=0)
-        self.opt = P.ApplyAdadelta()
-        self.op_cast = P.Cast()
+        self.opt = ops.ApplyAdadelta()
+        self.op_cast = ops.Cast()
 
     @jit
     def implementation(self, lr, rho, eps, maximize, weight_decay, start_id, end_id, gradients):
         """Extract the common computing part for acceleration"""
         params = self.parameters[start_id: end_id]
-        grads = tuple([grad if not maximize else F.neg(grad) for grad in gradients[start_id: end_id]])
+        grads = tuple([grad if not maximize else ops.neg(grad) for grad in gradients[start_id: end_id]])
         grads = self._decay_weight(weight_decay, params, grads)
         accum = self.accum[start_id: end_id]
         accum_update = self.accum_update[start_id: end_id]
-        self.hyper_map(F.partial(_adadelta_opt, self.opt, rho, eps, lr),
+        self.hyper_map(ops.partial(_adadelta_opt, self.opt, rho, eps, lr),
                        params, accum, accum_update, grads)
         return True
 

mindspore/experimental/optim/adagrad.py

@@ -1,34 +1,24 @@
-# 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.
+# The code implementation refers to the following files from pytorch:
+# - https://github.com/pytorch/pytorch/blob/v1.13.0/torch/optim/adagrad.py
+# Additional modifications are made by Huawei Technologies Co., Ltd in 2023.
 # ============================================================================
 """adagrad"""
 from __future__ import absolute_import
 
-from mindspore.ops import functional as F, composite as C, operations as P
+from mindspore import ops
 from mindspore.common import Tensor, Parameter
 import mindspore.common.dtype as mstype
 from mindspore.experimental.optim.optimizer import Optimizer, check_not_less_than, check_not_less_than_without_equal
 from mindspore import jit
 
-_adagrad_opt = C.MultitypeFuncGraph("adagrad_opt")
+_adagrad_opt = ops.MultitypeFuncGraph("adagrad_opt")
 
 
 @_adagrad_opt.register("Function", "Tensor", "Tensor", "Tensor", "Tensor")
 def _tensor_run_opt(opt, learning_rate, weight, accum, gradient):
     """Apply adagrad optimizer to the weight parameter."""
     success = True
-    success = F.depend(success, opt(weight, accum, learning_rate, gradient))
+    success = ops.depend(success, opt(weight, accum, learning_rate, gradient))
     return success
 
 
@@ -57,6 +47,9 @@ class Adagrad(Optimizer):
             &\rule{160mm}{0.4pt}                                                          \\[-1.ex]
        \end{aligned}
 
+    For more details about Adagrad algorithm, please refer to `Adaptive Subgradient Methods for Online Learning and \
+    Stochastic Optimization <https://jmlr.org/papers/v12/duchi11a.html>`_.
+
     .. warning::
         This is an experimental optimizer API that is subject to change.
         This module must be used with lr scheduler module in `LRScheduler Class
@@ -129,22 +122,22 @@ class Adagrad(Optimizer):
         super(Adagrad, self).__init__(params, defaults)
 
         self.accum = self.parameters.clone(prefix="accum", init=initial_accumulator_value)
-        self.op_cast = P.Cast()
+        self.op_cast = ops.Cast()
         self.step_t = Parameter(Tensor(0, mstype.int32), "step_t")
         self.increase_tensor = Tensor(1, mstype.int32)
-        self.assignadd = P.AssignAdd()
-        self.assign = P.Assign()
+        self.assignadd = ops.AssignAdd()
+        self.assign = ops.Assign()
 
     @jit
     def implementation(self, eps, lr, lr_decay, maximize, weight_decay, start_id, end_id, gradients):
         """Extract the common computing part for acceleration"""
-        opt = P.ApplyAdagradV2(epsilon=eps, update_slots=True)
+        opt = ops.ApplyAdagradV2(epsilon=eps, update_slots=True)
         decay_lr = lr / (1 + self.step_t * lr_decay)
         params = self.parameters[start_id: end_id]
-        grads = tuple([grad if not maximize else F.neg(grad) for grad in gradients[start_id: end_id]])
+        grads = tuple([grad if not maximize else ops.neg(grad) for grad in gradients[start_id: end_id]])
         grads = self._decay_weight(weight_decay, params, grads)
         accum = self.accum[start_id: end_id]
-        self.hyper_map(F.partial(_adagrad_opt, opt, decay_lr), params, accum, grads)
+        self.hyper_map(ops.partial(_adagrad_opt, opt, decay_lr), params, accum, grads)
         return True
 
     def construct(self, gradients):