mindspore 2.4.0__cp310-cp310-macosx_10_15_x86_64.whl

mindspore/hal/stream.py

@@ -0,0 +1,357 @@
+# 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.
+# ============================================================================
+"""Hal stream class"""
+from mindspore._c_expression import Stream as Stream_
+from mindspore._c_expression import set_cur_stream as set_cur_stream_
+from mindspore._c_expression import synchronize as synchronize_
+from mindspore._c_expression import current_stream as current_stream_
+from mindspore._c_expression import default_stream as default_stream_
+from mindspore._c_expression import communication_stream as communication_stream_
+
+from mindspore import _checkparam as Validator
+from .event import Event
+
+
+class Stream(Stream_):
+    r"""
+    Wrapper around a device stream.
+
+    A device stream is a linear sequence of execution that belongs to a specific device,
+    independent from other streams.
+
+    For a quick start of using Stream, please refer to `Illustration of stream management <https://www.mindspore.cn/docs/en/master/api_python/samples/hal/stream_manager.html>`_ .
+
+    Args:
+        priority (int, optional): priority of the stream, lower numbers represent higher priorities.
+            By default, streams have priority ``0``.
+        kwargs (dict): keyword arguments.
+    """
+    def __init__(self, priority=0, **kwargs):
+        self.init_finished = False
+        if 'stream' in kwargs and kwargs['stream'] is not None:
+            super().__init__(kwargs['stream'])
+
+        Validator.check_is_int(priority, 'priority', "Stream")
+        if 'stream_id' in kwargs:
+            Validator.check_is_int(kwargs['stream_id'], 'stream_id', "Stream")
+            super().__init__(priority, kwargs['stream_id'])
+        else:
+            super().__init__(priority)
+        self.init_finished = True
+
+    def record_event(self, event=None):
+        r"""
+        Records an event.
+
+        Args:
+            event (Event, optional): event to record. If not given, a new one
+                will be allocated.
+
+        Returns:
+            Event, recorded event. If this argument is ``None``, a new one will be allocated. Default is ``None``.
+
+        Raises:
+            TypeError: If 'event' is neither a :class:`mindspore.hal.Event` nor a ``None``.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> a = Tensor(np.ones([3, 3]), ms.float32)
+            >>> b = Tensor(np.ones([3, 3]), ms.float32)
+            >>> s1 = ms.hal.Stream()
+            >>> with ms.hal.StreamCtx(s1):
+            ...     c = a + b
+            ...     event = s1.record_event()
+            ...     d = a * b
+            >>> cur_stream = ms.hal.current_stream()
+            >>> cur_stream.wait_event(event)
+            >>> e = c + 3
+            >>> print(e)
+            [[5. 5. 5.]
+             [5. 5. 5.]
+             [5. 5. 5.]]
+        """
+        if event is None:
+            event = Event()
+        if not isinstance(event, Event):
+            raise TypeError(f"For 'record_event', the argument 'event' should be Event,"
+                            f" but got {type(event)}.")
+        event.record(self)
+        return event
+
+    def wait_event(self, event):
+        r"""
+        Makes all future work submitted to the stream wait for an event.
+
+        Args:
+            event (Event): an event to wait for.
+
+        Raises:
+            TypeError: If 'event' is not a :class:`mindspore.hal.Event`.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> a = Tensor(np.ones([3, 3]), ms.float32)
+            >>> b = Tensor(np.ones([3, 3]), ms.float32)
+            >>> s1 = ms.hal.Stream()
+            >>> with ms.hal.StreamCtx(s1):
+            ...     c = a + b
+            ...     event = s1.record_event()
+            ...     d = a * b
+            >>> cur_stream = ms.hal.current_stream()
+            >>> cur_stream.wait_event(event)
+            >>> e = c + 3
+            >>> print(e)
+            [[5. 5. 5.]
+             [5. 5. 5.]
+             [5. 5. 5.]]
+        """
+        if not isinstance(event, Event):
+            raise TypeError(f"For 'wait_event', the argument 'event' should be Event,"
+                            f" but got {type(event)}.")
+        event.wait(self)
+
+    def wait_stream(self, stream):
+        r"""
+        Synchronizes with another stream.
+
+        All future work submitted to this stream will wait until all kernels
+        submitted to a given stream at the time of call complete.
+
+        Args:
+            stream (Stream): a stream to synchronize.
+
+        Raises:
+            TypeError: If 'stream' is not a :class:`mindspore.hal.Stream`.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> s1 = ms.hal.Stream()
+            >>> s2 = ms.hal.Stream()
+            >>> a = Tensor(np.ones([1, 2]), ms.float32)
+            >>> b = Tensor(np.ones([2, 2]), ms.float32)
+            >>> with ms.hal.StreamCtx(s1):
+            ...     c = ops.matmul(a, b)
+            >>> with ms.hal.StreamCtx(s2):
+            ...     s2.wait_stream(s1)
+            ...     d = ops.matmul(c, b)
+            >>> ms.hal.synchronize()
+            >>> print(d)
+            [[4. 4.]]
+        """
+        if not isinstance(stream, Stream):
+            raise TypeError(f"For 'wait_stream', the argument 'stream' should be Stream,"
+                            f" but got {type(stream)}.")
+        self.wait_event(stream.record_event())
+
+    def synchronize(self):
+        r"""
+        Wait for all the kernels in this stream to complete.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
+            >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
+            >>> s1 = ms.hal.Stream()
+            >>> with ms.hal.StreamCtx(s1):
+            ...     c = ops.matmul(a, b)
+            >>> s1.synchronize()
+            >>> assert s1.query()
+        """
+        # pylint: disable=useless-super-delegation
+        super().synchronize()
+
+    def query(self):
+        r"""
+        Checks if all the work submitted has been completed.
+
+        Returns:
+            A boolean indicating if all kernels in this stream are completed.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
+            >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
+            >>> s1 = ms.hal.Stream()
+            >>> with ms.hal.StreamCtx(s1):
+            ...     c = ops.matmul(a, b)
+            >>> s1.synchronize()
+            >>> assert s1.query()
+        """
+        # pylint: disable=useless-super-delegation
+        return super().query()
+
+    def __eq__(self, other):
+        if not isinstance(other, Stream):
+            raise TypeError(f"For '__eq__', the argument 'other' should be Stream,"
+                            f" but got {type(other)}.")
+        return super().__eq__(other)
+
+    def __hash__(self):
+        return hash((self.id, self.device_id))
+
+    def __repr__(self):
+        if self.init_finished:
+            return super().__repr__()
+        return ''
+
+
+def synchronize():
+    r"""
+    Synchronize all streams on current device.(Each MindSpore process only occupies one device)
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
+        >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
+        >>> s1 = ms.hal.Stream()
+        >>> with ms.hal.StreamCtx(s1):
+        ...     c = ops.matmul(a, b)
+        >>> ms.hal.synchronize()
+        >>> assert s1.query()
+    """
+    synchronize_()
+
+
+def set_cur_stream(stream):
+    r"""
+    Sets the current stream.This is a wrapper API to set the stream.
+    Usage of this function is discouraged in favor of the ``stream`` context manager.
+
+    Args:
+        stream (Stream): selected stream. This function is a no-op
+            if this argument is ``None``.
+
+    Raises:
+        TypeError: If 'stream' is neither a :class:`mindspore.hal.Stream` nor a ``None``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> cur_stream = ms.hal.current_stream()
+        >>> assert cur_stream == ms.hal.default_stream()
+        >>> s1 = ms.hal.Stream()
+        >>> ms.hal.set_cur_stream(s1)
+        >>> assert ms.hal.current_stream() == s1
+        >>> ms.hal.set_cur_stream(ms.hal.default_stream())
+    """
+    if stream is None:
+        return
+    if not isinstance(stream, Stream):
+        raise TypeError(f"For 'set_cur_stream', the argument 'stream' should be Stream,"
+                        f" but got {type(stream)}.")
+    set_cur_stream_(stream)
+
+
+def current_stream():
+    r"""
+    Return current stream used on this device.
+
+    Returns:
+        stream (Stream), current stream.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> cur_stream = ms.hal.current_stream()
+        >>> assert cur_stream == ms.hal.default_stream()
+    """
+    return Stream(stream=current_stream_())
+
+
+def default_stream():
+    r"""
+    Return default stream on this device.
+
+    Returns:
+        stream (Stream), default stream.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> cur_stream = ms.hal.current_stream()
+        >>> assert cur_stream == ms.hal.default_stream()
+    """
+    return Stream(stream=default_stream_())
+
+
+def communication_stream():
+    r"""
+    Return default stream on this device.
+
+    Returns:
+        stream (Stream), default stream.
+
+    TODO
+    Examples:
+        >>> import mindspore as ms
+        >>> cur_stream = ms.hal.current_stream()
+        >>> assert cur_stream == ms.hal.default_stream()
+    """
+    return Stream(stream=communication_stream_())
+
+
+class StreamCtx():
+    r"""
+    Context-manager that selects a given stream.
+
+    All kernels queued within its context will be enqueued on a selected
+    stream.
+
+    Args:
+        ctx_stream (Stream): selected stream. This manager is a no-op if it's ``None``.
+
+    Raises:
+        TypeError: If 'stream' is neither a :class:`mindspore.hal.Stream` nor a ``None``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
+        >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
+        >>> s1 = ms.hal.Stream()
+        >>> with ms.hal.StreamCtx(s1):
+        ...     c = ops.matmul(a, b)
+        >>> ms.hal.synchronize()
+        >>> assert s1.query()
+    """
+    def __init__(self, ctx_stream):
+        if ctx_stream is not None and not isinstance(ctx_stream, Stream):
+            raise TypeError(f"For 'StreamCtx', the argument 'ctx_stream' should be Stream,"
+                            f" but got {type(ctx_stream)}.")
+        self.stream = ctx_stream
+        self.prev_stream = None
+
+    def __enter__(self):
+        if self.stream is None:
+            return
+        self.prev_stream = current_stream()
+        set_cur_stream(self.stream)
+        return
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.stream is None:
+            return
+        set_cur_stream(self.prev_stream)
+        return

mindspore/include/OWNERS

@@ -0,0 +1,7 @@
+approvers:
+- jpc_chenjianping #
+- zhang_xue_tong
+reviewers:
+- lx0095
+- xu-yfei
+- wilfchen

mindspore/include/api/allocator.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2021 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 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.
+ */
+
+#ifndef MINDSPORE_INCLUDE_API_ALLOCATOR_H
+#define MINDSPORE_INCLUDE_API_ALLOCATOR_H
+
+#include <memory>
+#include "include/api/types.h"
+
+namespace mindspore {
+/// \brief Allocator defined a memory pool for malloc memory and free memory dynamically.
+class MS_API Allocator {
+ public:
+  /// \brief Destructor of MindSpore Allocator.
+  virtual ~Allocator() = default;
+
+  /// \brief Method to request memory.
+  ///
+  /// \param[in] size Define the memory size to request.
+  virtual void *Malloc(size_t size) = 0;
+
+  /// \brief Method to request memory.
+  ///
+  /// \param[in] weight Defines the width of memory to request
+  /// \param[in] height Defines the height of memory to request
+  /// \param[in] type Defines the data type of memory to request
+  virtual void *Malloc(size_t weight, size_t height, DataType type) {
+    return nullptr;
+  }
+
+  /// \brief Method to free memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  virtual void Free(void *ptr) = 0;
+
+  /// \brief Reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  ///
+  /// \return Reference count of a certain memory currently.
+  virtual int RefCount(void *ptr) = 0;
+
+  /// \brief Set reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to set.
+  ///
+  /// \return Reference count of a certain memory after setting.
+  virtual int SetRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Decrease the reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to reduce.
+  ///
+  /// \return Reference count of a certain memory after decreating.
+  virtual int DecRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Increase the reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to increase.
+  ///
+  /// \return Reference count of a certain memory after increasing.
+  virtual int IncRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Static method to create an allocator.
+  ///
+  /// \return Smart pointer of an allocator.
+  static std::shared_ptr<Allocator> Create();
+
+  /// \brief Prepare a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory to prepare.
+  ///
+  /// \return Pointer of ready memory.
+  virtual void *Prepare(void *ptr) { return ptr; }
+
+ protected:
+  // memory aligned bytes
+  size_t aligned_size_ = 32;
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_ALLOCATOR_H

mindspore/include/api/callback/callback.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright 2021-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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_CALLBACK_CALLBACK_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_CALLBACK_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include "include/api/data_type.h"
+#include "include/api/dual_abi_helper.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+class Model;
+class ModelImpl;
+class CallbackImpl;
+
+using GraphPoint = std::pair<int, float>;
+
+struct MS_API TrainCallBackData {
+  TrainCallBackData(bool train_mode, int epoch, int step, Model *model)
+      : train_mode_(train_mode), epoch_(epoch), step_(step), model_(model) {}
+
+  bool train_mode_;       /**< training mode of LiteSession object */
+  unsigned int epoch_;    /**< the current training epoch (starts at 0) */
+  unsigned int step_ = 0; /**< the current step within the epoch */
+  Model *model_;          /**< pointer to the Model object */
+};
+
+enum CallbackRetValue : uint32_t { kContinue = 0, kStopTraining = 1, kExit = 2, kUnknownRetValue = 0xFFFFFFFF };
+
+class MS_API TrainCallBack {
+ public:
+  virtual ~TrainCallBack() = default;
+
+  /// \brief This method is called once before the network executing
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void Begin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called once following the network execution
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void End(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called at the beginning of each epoch
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void EpochBegin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called after the run of each epoch
+  ///
+  /// \param[in] cb_data info about current execution
+  ///
+  /// \return indication if to continue in the train loop:
+  ///         RET_CONTINUE -- continue training
+  ///         RET_STOP_TRAINING -- stop training (e.g., due to achieved accuracy)
+  ///         RET_EXIT -- Exit training (due to error of some sort)
+  virtual CallbackRetValue EpochEnd(const TrainCallBackData &cb_data) { return kContinue; }
+
+  /// \brief This method is called at the beginning of each step
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void StepBegin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called after each step is ran
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void StepEnd(const TrainCallBackData &cb_data) {}
+
+ protected:
+  friend class Model;
+  friend class ModelImpl;
+  CallbackImpl *callback_impl_ = nullptr;
+};
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_CALLBACK_H

mindspore/include/api/callback/ckpt_saver.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2021-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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_CALLBACK_CKPT_SAVER_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_CKPT_SAVER_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/callback/callback.h"
+#include "include/api/dual_abi_helper.h"
+
+namespace mindspore {
+
+class MS_API CkptSaver : public TrainCallBack {
+ public:
+  inline CkptSaver(int save_every_n, const std::string &filename_prefix);
+  virtual ~CkptSaver();
+
+ private:
+  CkptSaver(int save_every_n, const std::vector<char> &filename_prefix);
+};
+
+CkptSaver::CkptSaver(int save_every_n, const std::string &filename_prefix)
+    : CkptSaver(save_every_n, StringToChar(filename_prefix)) {}
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_CKPT_SAVER_H

mindspore/include/api/callback/loss_monitor.h

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2021-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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_CALLBACK_LOSS_MONITOR_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_LOSS_MONITOR_H
+
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include "include/api/callback/callback.h"
+
+namespace mindspore {
+
+class MS_API LossMonitor : public TrainCallBack {
+ public:
+  explicit LossMonitor(int print_every_n_steps = INT_MAX);
+  virtual ~LossMonitor();
+  const std::vector<GraphPoint> &GetLossPoints();
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_LOSS_MONITOR_H

mindspore/include/api/callback/lr_scheduler.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright 2021-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.
+ */
+#ifndef MINDSPORE_INCLUDE_API_CALLBACK_LR_SCHEDULER_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_LR_SCHEDULER_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/callback/callback.h"
+
+namespace mindspore {
+
+constexpr int DONT_UPDATE_LR = 0;
+constexpr int UPDATE_LR = 1;
+
+using LR_Lambda = std::function<int(float *lr, int epoch, void *cb_data)>;
+
+/// \brief Multiply the LR by a factor of gamma every epoch
+MS_API int MultiplicativeLRLambda(float *lr, int epoch, void *multiplication);
+
+/// \brief Multiply the LR by a factor of gamma every step_size
+MS_API int StepLRLambda(float *lr, int epoch, void *step_size);
+struct MS_API StepLRLambda {
+  StepLRLambda(int step, float g) : step_size(step), gamma(g) {}
+
+  int step_size;  // period of LR decay
+  float gamma;    // LR decay factor
+};
+
+class MS_API LRScheduler : public TrainCallBack {
+ public:
+  explicit LRScheduler(LR_Lambda lambda_func, void *lr_cb_data = nullptr, int step = 1);
+  virtual ~LRScheduler();
+};
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_LR_SCHEDULER_H