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

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 {

mindspore/include/dataset/vision.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2023 Huawei Technologies Co., Ltd
+ * Copyright 2020-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.
@@ -20,6 +20,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -440,6 +441,36 @@ class DATASET_API CutOut final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
+/// \brief Decode the input video.
+class DATASET_API DecodeVideo final : public TensorTransform {
+ public:
+  /// \brief Constructor. It will decode a vector containing a raw video tensor into a vector containing two tensors.
+  ///     The raw video tensor in the input vector should be 1D array of UINT8.
+  ///     The first tensor in the output vector is a visual tensor, the shape is <T,H,W,C>, the type is DE_UINT8. Pixel
+  ///     order is RGB. The second tensor in the output vector is an audio tensor, the shape is <C, L>.
+  /// \par Example
+  /// \code
+  ///     /* Read video file into tensor */
+  ///     mindspore::MSTensor video;
+  ///     ASSERT_OK(mindspore::dataset::vision::ReadFile("/path/to/video/file", &video));
+  ///     std::vector<mindspore::MSTensor> input_tensor;
+  ///     std::vector<mindspore::MSTensor> output_tensor;
+  ///     input_tensor.push_back(video);
+  ///     auto decode_video = vision::DecodeVideo();
+  ///     auto transform = Execute(decode_video);
+  ///     Status rc = transform(input_tensor, &output_tensor);
+  /// \endcode
+  DecodeVideo();
+
+  /// \brief Destructor.
+  ~DecodeVideo() = default;
+
+ protected:
+  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+};
+
 /// \brief Encode the image as JPEG data.
 /// \param[in] image The image to be encoded.
 /// \param[out] output The Tensor data.
@@ -495,7 +526,7 @@ class DATASET_API Erase final : public TensorTransform {
   ///                             std::make_shared<vision::Erase>(10, 10, 10, 10)}, // operations
   ///                            {"image"});                                        // input columns
   /// \endcode
-  Erase(int32_t top, int32_t left, int32_t height, int32_t width, const std::vector<uint8_t> &value = {0, 0, 0},
+  Erase(int32_t top, int32_t left, int32_t height, int32_t width, const std::vector<float> &value = {0., 0., 0.},
         bool inplace = false);
 
   /// \brief Destructor.
@@ -1686,6 +1717,27 @@ Status DATASET_API ReadFile(const std::string &filename, mindspore::MSTensor *ou
 Status DATASET_API ReadImage(const std::string &filename, mindspore::MSTensor *output,
                              ImageReadMode mode = ImageReadMode::kUNCHANGED);
 
+/// \brief Read the video, audio, metadata from a video file. It supports AVI, H264, H265, MOV, MP4, WMV file formats.
+/// \param[in] filename The path to the videoe file to be read.
+/// \param[out] video_output The video frames of the video file.
+/// \param[out] audio_output The audio frames of the video file.
+/// \param[out] metadata_output The metadata contains video_fps, audio_fps.
+/// \param[in] start_pts The start presentation timestamp of the video. Default: 0.0.
+/// \param[in] end_pts The end presentation timestamp of the video. Default: 2147483647.0.
+/// \param[in] pts_unit The unit for the timestamps, can be one of ["pts", "sec"]. Default: "pts".
+/// \return The status code.
+Status DATASET_API ReadVideo(const std::string &filename, mindspore::MSTensor *video_output,
+                             mindspore::MSTensor *audio_output, std::map<std::string, std::string> *metadata_output,
+                             float start_pts = 0.0, float end_pts = 2147483647.0, const std::string &pts_unit = "pts");
+
+/// \brief Read the timestamps and frame rate of a video file. It supports AVI, H264, H265, MOV, MP4, WMV files.
+/// \param[in] filename The path to the videoe file to be read.
+/// \param[out] output The tuple(video_timestamps, video_fps) of the video.
+/// \param[in] pts_unit The unit for the timestamps, can be one of ["pts", "sec"]. Default: "pts".
+/// \return The status code.
+Status DATASET_API ReadVideoTimestamps(const std::string &filename, std::tuple<std::vector<float>, float> *output,
+                                       const std::string &pts_unit = "pts");
+
 /// \brief Crop the given image and zoom to the specified size.
 class DATASET_API ResizedCrop final : public TensorTransform {
  public:

mindspore/log.py

@@ -234,11 +234,11 @@ def get_level():
 
     Examples:
         >>> import os
+        >>> os.environ['GLOG_v'] = '3'
         >>> import mindspore as ms
-        >>> os.environ['GLOG_v'] = '0'
         >>> level = ms.get_level()
         >>> print(level)
-        '0'
+        '3'
     """
     # level and glog level mapping dictionary
     level_to_glog_level = dict(zip(_name_to_level.values(), _gloglevel_to_name.keys()))

mindspore/mindrecord/__init__.py

@@ -19,7 +19,9 @@ MindRecord is a module to implement reading, writing, searching and
 converting for MindSpore format dataset. Users could use the FileWriter
 API to generate MindRecord data and use the MindDataset API to load
 MindRecord data. Users could also convert other format datasets to
-mindrecord data through corresponding sub-module.
+mindrecord data through corresponding sub-module. You can also
+configure encryption, decryption, and integrity check to ensure
+the security of MindRecord datasets.
 """
 
 from .filewriter import FileWriter
@@ -33,7 +35,9 @@ from .tools.csv_to_mr import CsvToMR
 from .tools.imagenet_to_mr import ImageNetToMR
 from .tools.mnist_to_mr import MnistToMR
 from .tools.tfrecord_to_mr import TFRecordToMR
+from .config import *
 
 __all__ = ['FileWriter', 'FileReader', 'MindPage',
            'Cifar10ToMR', 'Cifar100ToMR', 'CsvToMR', 'ImageNetToMR', 'MnistToMR', 'TFRecordToMR',
+           'set_enc_key', 'set_enc_mode', 'set_dec_mode', 'set_hash_mode',
            'SUCCESS', 'FAILED']