mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/hal/stream.py

@@ -0,0 +1,339 @@
+# 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 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_())
+
+
+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/api/data_type.h

@@ -38,8 +38,8 @@ enum class DataType : int {
   kNumberTypeFloat16 = 42,
   kNumberTypeFloat32 = 43,
   kNumberTypeFloat64 = 44,
-  kNumberTypeBFloat16 = 46,
-  kNumberTypeEnd = 53,
+  kNumberTypeBFloat16 = 45,
+  kNumberTypeEnd = 52,
   // add new enum here
   kInvalidType = INT32_MAX,
 };

mindspore/include/api/dual_abi_helper.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2021 Huawei Technologies Co., Ltd
+ * Copyright 2021-2024 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.
@@ -27,9 +27,22 @@
 #include <vector>
 
 namespace mindspore {
-inline std::vector<char> StringToChar(const std::string &s) { return std::vector<char>(s.begin(), s.end()); }
+using VecChar = std::vector<char>;
+inline std::vector<char> StringToChar(const std::string &s) {
+  if (s.empty()) {
+    const auto empty = std::vector<char>();
+    return empty;
+  }
+  return std::vector<char>(s.begin(), s.end());
+}
 
-inline std::string CharToString(const std::vector<char> &c) { return std::string(c.begin(), c.end()); }
+inline std::string CharToString(const std::vector<char> &c) {
+  if (c.empty()) {
+    const auto empty = "";
+    return empty;
+  }
+  return std::string(c.begin(), c.end());
+}
 
 inline std::pair<std::vector<char>, int32_t> PairStringToChar(const std::pair<std::string, int32_t> &s) {
   return std::pair<std::vector<char>, int32_t>(std::vector<char>(s.first.begin(), s.first.end()), s.second);

mindspore/include/api/model.h

@@ -135,14 +135,12 @@ class MS_API Model {
   ///
   /// \return Status.
   Status UpdateWeights(const std::vector<MSTensor> &new_weights);
-
   /// \brief Change the size and or content of weight tensors
   ///
-  /// \param[in]  A vector where model constant are arranged in sequence
+  /// \param[in] new_weights A vector where model constant are arranged in sequence
   ///
   /// \return Status.
   Status UpdateWeights(const std::vector<std::vector<MSTensor>> &new_weights);
-
   /// \brief Inference model API. If use this API in train mode, it's equal to RunStep API.
   ///
   /// \param[in] inputs A vector where model inputs are arranged in sequence.
@@ -372,6 +370,9 @@ class MS_API Model {
   /// \return The value of the model info associated with the given key.
   inline std::string GetModelInfo(const std::string &key);
 
+  // release inference resourcec, only used for mindspore_lite's ascend backend now.
+  Status Finalize();
+
  private:
   friend class Serialization;
   // api without std::string

mindspore/include/api/status.h

@@ -91,6 +91,20 @@ enum StatusCode : uint32_t {
   kLiteLLMRepeatRequest = kLite | (0x0FFFFFFF & -105),           /**< repeat request. */
   kLiteLLMRequestAlreadyCompleted = kLite | (0x0FFFFFFF & -106), /**< request already complete!. */
   kLiteLLMEngineFinalized = kLite | (0x0FFFFFFF & -107),         /**< llm engine finalized. */
+  kLiteLLMNotYetLink = kLite | (0x0FFFFFFF & -108),              /**< decoder cluster is no link with prompt. */
+  kLiteLLMAlreadyLink = kLite | (0x0FFFFFFF & -109),  /**< decoder cluster is already linked with prompt cluster! */
+  kLiteLLMLinkFailed = kLite | (0x0FFFFFFF & -110),   /**< decoder cluster link with prompt cluster failed! */
+  kLiteLLMUnlinkFailed = kLite | (0x0FFFFFFF & -111), /**< decoder cluster unlink with prompt cluster failed */
+  kLiteLLMNofiryPromptUnlinkFailed =
+    kLite | (0x0FFFFFFF & -112), /**< decoder cluster notify prompt cluster do unlink failed */
+  kLiteLLMClusterNumExceedLimit = kLite | (0x0FFFFFFF & -113), /**< cluster num exceed limit */
+  kLiteLLMProcessingLink = kLite | (0x0FFFFFFF & -114),        /**< link is current processing. */
+  kLiteLLMOutOfMemory = kLite | (0x0FFFFFFF & -115),           /**< device out of memory. */
+  kLiteLLMPrefixAlreadyExist = kLite | (0x0FFFFFFF & -116),    /**< Prefix has already existed. */
+  kLiteLLMPrefixNotExist = kLite | (0x0FFFFFFF & -117),        /**< Prefix does not exist. */
+  kLiteLLMSeqLenOverLimit = kLite | (0x0FFFFFFF & -118),       /**< Sequence length exceed limit. */
+  kLiteLLMNoFreeBlock = kLite | (0x0FFFFFFF & -119),           /**< No free block. */
+  kLiteLLMBlockOutOfMemory = kLite | (0x0FFFFFFF & -120),      /**< Block is out of memory. */
 
   // Graph error code, range: [-200,-300)
   kLiteGraphFileError = kLite | (0x0FFFFFFF & -200), /**< Failed to verify graph file. */

mindspore/include/c_api/model_c.h

@@ -26,6 +26,8 @@ extern "C" {
 
 typedef void *MSModelHandle;
 
+typedef void *MSTrainCfgHandle;
+
 typedef struct MSTensorHandleArray {
   size_t handle_num;
   MSTensorHandle *handle_list;
@@ -168,6 +170,177 @@ MS_API MSTensorHandle MSModelGetInputByTensorName(const MSModelHandle model, con
 /// \return The output tensor handle with the given name, if the name is not found, an NULL is returned.
 MS_API MSTensorHandle MSModelGetOutputByTensorName(const MSModelHandle model, const char *tensor_name);
 
+/// \brief Create a TrainCfg object. Only valid for Lite Train.
+///
+/// \return TrainCfg object handle.
+MS_API MSTrainCfgHandle MSTrainCfgCreate();
+
+/// \brief Destroy the train_cfg object. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+MS_API void MSTrainCfgDestroy(MSTrainCfgHandle *train_cfg);
+
+/// \brief Obtains part of the name that identify a loss kernel. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] num The num of loss_name.
+///
+/// \return loss_name.
+MS_API char **MSTrainCfgGetLossName(MSTrainCfgHandle train_cfg, size_t *num);
+
+/// \brief Set part of the name that identify a loss kernel. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] loss_name define part of the name that identify a loss kernel.
+/// \param[in] num The num of loss_name.
+MS_API void MSTrainCfgSetLossName(MSTrainCfgHandle train_cfg, const char **loss_name, size_t num);
+
+/// \brief Obtains optimization level of the train_cfg. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+///
+/// \return MSOptimizationLevel.
+MS_API MSOptimizationLevel MSTrainCfgGetOptimizationLevel(MSTrainCfgHandle train_cfg);
+
+/// \brief Set optimization level of the train_cfg. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] level The optimization level of train_cfg.
+MS_API void MSTrainCfgSetOptimizationLevel(MSTrainCfgHandle train_cfg, MSOptimizationLevel level);
+
+/// \brief Build the train model from model buffer so that it can run on a device. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] model_data Define the buffer read from a model file.
+/// \param[in] data_size Define bytes number of model file buffer.
+/// \param[in] model_type Define The type of model file.
+/// \param[in] model_context Define the context used to store options during execution.
+/// \param[in] train_cfg Define the config used by training.
+///
+/// \return MSStatus.
+MS_API MSStatus MSTrainModelBuild(MSModelHandle model, const void *model_data, size_t data_size, MSModelType model_type,
+                                  const MSContextHandle model_context, const MSTrainCfgHandle train_cfg);
+
+/// \brief Build the train model from model file buffer so that it can run on a device. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] model_path Define the model path.
+/// \param[in] model_type Define The type of model file.
+/// \param[in] model_context Define the context used to store options during execution.
+/// \param[in] train_cfg Define the config used by training.
+///
+/// \return MSStatus.
+MS_API MSStatus MSTrainModelBuildFromFile(MSModelHandle model, const char *model_path, MSModelType model_type,
+                                          const MSContextHandle model_context, const MSTrainCfgHandle train_cfg);
+
+/// \brief Train model by step. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] before CallBack before predict.
+/// \param[in] after CallBack after predict.
+///
+/// \return MSStatus.
+MS_API MSStatus MSRunStep(MSModelHandle model, const MSKernelCallBackC before, const MSKernelCallBackC after);
+
+/// \brief Sets the Learning Rate of the training. Only valid for Lite Train.
+///
+/// \param[in] learning_rate to set.
+///
+/// \return MSStatus of operation.
+MS_API MSStatus MSModelSetLearningRate(MSModelHandle model, float learning_rate);
+
+/// \brief Obtains the Learning Rate of the optimizer. Only valid for Lite Train.
+///
+/// \return Learning rate. 0.0 if no optimizer was found.
+MS_API float MSModelGetLearningRate(MSModelHandle model);
+
+/// \brief Obtains all weights tensors of the model. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+///
+/// \return The vector that includes all gradient tensors.
+MS_API MSTensorHandleArray MSModelGetWeights(MSModelHandle model);
+
+/// \brief update weights tensors of the model. Only valid for Lite Train.
+///
+/// \param[in] new_weights A vector new weights.
+///
+/// \return MSStatus
+MS_API MSStatus MSModelUpdateWeights(MSModelHandle model, const MSTensorHandleArray new_weights);
+
+/// \brief Get the model running mode.
+///
+/// \param[in] model Model object handle.
+///
+/// \return Is Train Mode or not.
+MS_API bool MSModelGetTrainMode(MSModelHandle model);
+
+/// \brief Set the model running mode. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] train True means model runs in Train Mode, otherwise Eval Mode.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelSetTrainMode(MSModelHandle model, bool train);
+
+/// \brief Setup training with virtual batches. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] virtual_batch_multiplier - virtual batch multiplier, use any number < 1 to disable.
+/// \param[in] lr - learning rate to use for virtual batch, -1 for internal configuration.
+/// \param[in] momentum - batch norm momentum to use for virtual batch, -1 for internal configuration.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelSetupVirtualBatch(MSModelHandle model, int virtual_batch_multiplier, float lr, float momentum);
+
+/// \brief Export training model from file. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] model_file The exported model file.
+/// \param[in] quantization_type The quantification type.
+/// \param[in] export_inference_only Whether to export a reasoning only model.
+/// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
+/// empty, and export the complete reasoning model.
+/// \param[in] num The number of output_tensor_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportModel(MSModelHandle model, MSModelType model_type, const char *model_file,
+                              MSQuantizationType quantization_type, bool export_inference_only,
+                              char **output_tensor_name, size_t num);
+
+/// \brief Export training model from buffer. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] model_data The exported model buffer.
+/// \param[in] data_size The exported model buffer size.
+/// \param[in] quantization_type The quantification type.
+/// \param[in] export_inference_only Whether to export a reasoning only model.
+/// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
+/// empty, and export the complete reasoning model.
+/// \param[in] num The number of output_tensor_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportModelBuffer(MSModelHandle model, MSModelType model_type, char **model_data, size_t *data_size,
+                                    MSQuantizationType quantization_type, bool export_inference_only,
+                                    char **output_tensor_name, size_t num);
+
+/// \brief Export model's weights, which can be used in micro only. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] weight_file The path of exported weight file.
+/// \param[in] is_inference Whether to export weights from a reasoning model. Currently, only support this is `true`.
+/// \param[in] enable_fp16 Float-weight is whether to be saved in float16 format.
+/// \param[in] changeable_weights_name The set the name of these weight tensors, whose shape is changeable.
+/// \param[in] num The number of changeable_weights_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportWeightsCollaborateWithMicro(MSModelHandle model, MSModelType model_type,
+                                                    const char *weight_file, bool is_inference, bool enable_fp16,
+                                                    char **changeable_weights_name, size_t num);
+
 #ifdef __cplusplus
 }
 #endif

mindspore/include/c_api/ms/base/types.h

@@ -250,6 +250,7 @@ typedef enum PadMode {
   PAD = 0,
   SAME = 1,
   VALID = 2,
+  FULL = 3,
 } PadMode;
 
 typedef enum Format {

mindspore/include/c_api/types_c.h

@@ -42,6 +42,25 @@ typedef enum MSDeviceType {
   kMSDeviceTypeInvalid = 100,
 } MSDeviceType;
 
+typedef enum MSOptimizationLevel {
+  /** Do not change */
+  kMSKO0 = 0,
+  /** Cast network to float16, keep batchnorm and loss in float32 */
+  kMSKO2 = 2,
+  /** Cast network to float16, including bacthnorm */
+  kMSKO3 = 3,
+  /** Choose optimization based on device */
+  kMSKAUTO = 4,
+  kMSKOPTIMIZATIONTYPE = 0xFFFFFFFF
+} MSOptimizationLevel;
+
+typedef enum MSQuantizationType {
+  kMSNO_QUANT = 0,
+  kMSWEIGHT_QUANT = 1,
+  kMSFULL_QUANT = 2,
+  kMSUNKNOWN_QUANT_TYPE = 0xFFFFFFFF
+} MSQuantizationType;
+
 #ifdef __cplusplus
 }
 #endif

mindspore/include/dataset/execute.h

@@ -152,7 +152,7 @@ class DATASET_API Execute {
 
  protected:
   /// \brief The function to convert TensorTransforms into TensorOperations and then build TensorOps.
-  Status BuildTransforms();
+  Status BuildTransforms(std::vector<std::shared_ptr<TensorOp>> *transforms_rt);
 
   /// \brief The function to convert a TensorTransform object into a TensorOperation object.
   Status ParseTransforms();
@@ -177,8 +177,6 @@ class DATASET_API Execute {
   device::DeviceContext *device_context_ = nullptr;
   size_t stream_id_;
 #endif
-
-  std::vector<std::shared_ptr<TensorOp>> transforms_rt_;
 };
 
 class PyExecute : public Execute {