mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/hal/memory.py

@@ -14,14 +14,18 @@
 # ============================================================================
 
 """Hardware memory interfaces."""
-from mindspore._c_expression import _memory_stats, _reset_max_mem_reserved, _reset_max_mem_allocated
+from mindspore._c_expression import _memory_stats, _reset_max_mem_reserved, _reset_max_mem_allocated, _empty_cache, \
+    DeviceContextManager
 from mindspore import log as logger
+import mindspore as ms
 from .device import _check_inputs_validation, is_initialized
 
+
 function_memory_status = {'memory_stats': False, 'memory_reserved': False, 'max_memory_reserved': False,
                           'empty_cache': False, 'reset_peak_memory_stats': False, 'memory_summary': False,
                           'memory_allocated': False, 'max_memory_allocated': False,
                           'reset_max_memory_reserved': False, 'reset_max_memory_allocated': False}
+_device_context_mgr = DeviceContextManager.get_instance()
 
 
 @_check_inputs_validation
@@ -131,20 +135,36 @@ def max_memory_reserved(device_target=None):
     return _memory_stats(device_target).get("max_reserved_memory", 0)
 
 
+def _is_initialized(device_target):
+    """
+    Returns whether specified backend is initialized.
+    """
+    _device_context = _device_context_mgr.get_device_context(device_target)
+    if _device_context is None:
+        return False
+    return _device_context.initialized()
+
+
 @_check_inputs_validation
 def empty_cache():
     """
-    Release all memory fragments in the memory pool, so that memory arrangement
-    will be optimized, this api will be deprecated and removed in future versions, please use
-    the api :func:`mindspore.runtime.empty_cache` instead.
+    Empty cache in the memory pool, this api will be deprecated and removed in future versions.
+    Please use the api :func:`mindspore.runtime.empty_cache` instead.
 
     Note:
-        Currently, the MindSpore memory pool does not have the function of releasing memory fragments.
-        This interface is reserved but implemented as an empty method and prompted in log mode when using.
+        - Empty cache help reduce the fragmentation of device memory.
+        - Support Atlas A2 series products.
+
+    Supported Platforms:
+        ``Ascend``
     """
     if not function_memory_status['empty_cache']:
         function_memory_status['empty_cache'] = True
-        logger.warning(f"The empty_cache operation is currently not supported.")
+    device_target = ms.context.get_context("device_target")
+    if not _is_initialized(device_target):
+        logger.warning(f"Backend {device_target} is not initialized yet.")
+        return
+    _empty_cache(device_target)
 
 
 @_check_inputs_validation

mindspore/include/api/cell.h

@@ -33,8 +33,22 @@ class MS_API CellBase {
  public:
   CellBase() = default;
   virtual ~CellBase() = default;
+  /// \brief Construct using inputs.
+  ///
+  /// \param[in] inputs Vector of inputs.
+  ///
+  /// \return Vector of outputs.
   virtual std::vector<Output> Construct(const std::vector<Input> &inputs) { return {}; }
+  /// \brief Clone a cellbase.
+  ///
+  /// \return Shared pointer of Cellbase.
   virtual std::shared_ptr<CellBase> Clone() const = 0;
+  /// \brief Run a cellbase.
+  ///
+  /// \param[in] inputs Vector of MSTensor as inputs.
+  /// \param[in] outputs Vector of MSTensor as outputs.
+  ///
+  /// \return Status of the operation.
   virtual Status Run(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) { return kSuccess; }
   std::vector<Output> operator()(const std::vector<Input> &inputs) const;
 };
@@ -56,12 +70,34 @@ class MS_API GraphCell final : public Cell<GraphCell> {
   explicit GraphCell(const Graph &graph);
   explicit GraphCell(Graph &&graph);
   explicit GraphCell(const std::shared_ptr<Graph> &graph);
-
+  /// \brief Set a context.
+  ///
+  /// \param[in] context Context to be set.
   void SetContext(const std::shared_ptr<Context> &context);
+  /// \brief Get back the graph.
+  ///
+  /// \return Graph of the graphcell.
   const std::shared_ptr<Graph> &GetGraph() const { return graph_; }
+  /// \brief Run the graphcell.
+  ///
+  /// \param[in] inputs Vector of MSTensor as inputs.
+  /// \param[in] outputs Vector of MSTensor as outputs.
+  ///
+  /// \return Status of the operation.
   Status Run(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) override;
+  /// \brief Get the inputs.
+  ///
+  /// \return Inputs.
   std::vector<MSTensor> GetInputs();
+  /// \brief Get the outputs.
+  ///
+  /// \return Outputs.
   std::vector<MSTensor> GetOutputs();
+  /// \brief Load the device.
+  ///
+  /// \param[in] device_id Device id to be loaded.
+  ///
+  /// \return Status of the operation.
   Status Load(uint32_t device_id);
 
  private:

mindspore/include/api/delegate.h

@@ -130,11 +130,21 @@ class Delegate : public IDelegate<LiteDelegateGraph, kernel::Kernel, kernel::Ker
   /// \return Status. If Status is kLiteNotSupport, the program will return to the MindSpore Lite inner inference.
   virtual Status Init() = 0;
 
+  /// \brief Create kernel.
+  ///
+  /// \param[in] node The kernel to be created.
+  ///
+  /// \return Created kernel.
   std::shared_ptr<kernel::Kernel> CreateKernel(const std::shared_ptr<kernel::Kernel> &node) override {
     // return node as kernel since they are same one.
     return node;
   }
 
+  /// \brief Check if the node is delegate node.
+  ///
+  /// \param[in] node The kernel to verify.
+  ///
+  /// \return True if the node is delegate.
   bool IsDelegateNode(const std::shared_ptr<kernel::Kernel> &node) override { return false; }
 
   /// \brief Replace the nodes in model with delegate nodes, delegate will create kernels by its delegate nodes.

mindspore/include/api/model.h

@@ -370,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);
 
+  /// \brief Finish the model. (Only used for mindspore_lite's ascend backend.)
+  ///
+  /// \return Status of the operation.
   // release inference resourcec, only used for mindspore_lite's ascend backend now.
   Status Finalize();
 

mindspore/include/api/types.h

@@ -243,14 +243,14 @@ class MS_API MSTensor {
 
   /// \brief Get the boolean value that indicates whether the MSTensor equals tensor.
   ///
-  /// \param[in] another MSTensor.
+  /// \param[in] tensor MSTensor.
   ///
   /// \return The boolean value that indicates whether the MSTensor equals tensor.
   bool operator==(const MSTensor &tensor) const;
 
   /// \brief Get the boolean value that indicates whether the MSTensor not equals tensor.
   ///
-  /// \param[in] another MSTensor.
+  /// \param[in] tensor MSTensor.
   ///
   /// \return The boolean value that indicates whether the MSTensor not equals tensor.
   bool operator!=(const MSTensor &tensor) const;

mindspore/include/c_api/model_c.h

@@ -48,140 +48,111 @@ typedef bool (*MSKernelCallBackC)(const MSTensorHandleArray inputs, const MSTens
                                   const MSCallBackParamC kernel_Info);
 
 /// \brief Create a model object.
-///
 /// \return Model object handle.
 MS_API MSModelHandle MSModelCreate();
 
 /// \brief Destroy the model object.
-///
 /// \param[in] model Model object handle address.
 MS_API void MSModelDestroy(MSModelHandle *model);
 
 /// \brief Set workspace for the model object. Only valid for Iot.
-///
 /// \param[in] model Model object handle.
 /// \param[in] workspace Define the workspace address.
 /// \param[in] workspace_size Define the workspace size.
 MS_API void MSModelSetWorkspace(MSModelHandle model, void *workspace, size_t workspace_size);
 
 /// \brief Calculate the workspace size required for model inference. Only valid for Iot.
-///
 /// \param[in] model Model object handle.
 MS_API size_t MSModelCalcWorkspaceSize(MSModelHandle model);
 
 /// \brief Build the model from model file buffer so that it can run on a device.
-///
 /// \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.
-///
 /// \return MSStatus.
 MS_API MSStatus MSModelBuild(MSModelHandle model, const void *model_data, size_t data_size, MSModelType model_type,
                              const MSContextHandle model_context);
 
 /// \brief Load and build the model from model path so that it can run on a device.
-///
 /// \param[in] model Model object handle.
 /// \param[in] model_path Define the model file path.
 /// \param[in] model_type Define The type of model file.
 /// \param[in] model_context Define the context used to store options during execution.
-///
 /// \return MSStatus.
 MS_API MSStatus MSModelBuildFromFile(MSModelHandle model, const char *model_path, MSModelType model_type,
                                      const MSContextHandle model_context);
 
 /// \brief Resize the shapes of inputs.
-///
 /// \param[in] model Model object handle.
 /// \param[in] inputs The array that includes all input tensor handles.
 /// \param[in] shape_infos Defines the new shapes of inputs, should be consistent with inputs.
 /// \param[in] shape_info_num The num of shape_infos.
-///
 /// \return MSStatus.
 MS_API MSStatus MSModelResize(MSModelHandle model, const MSTensorHandleArray inputs, MSShapeInfo *shape_infos,
                               size_t shape_info_num);
 
 /// \brief Inference model.
-///
 /// \param[in] model Model object handle.
 /// \param[in] inputs The array that includes all input tensor handles.
 /// \param[out] outputs The array that includes all output tensor handles.
 /// \param[in] before CallBack before predict.
 /// \param[in] after CallBack after predict.
-///
 /// \return MSStatus.
 MS_API MSStatus MSModelPredict(MSModelHandle model, const MSTensorHandleArray inputs, MSTensorHandleArray *outputs,
                                const MSKernelCallBackC before, const MSKernelCallBackC after);
 
 /// \brief Run model by step. Only valid for Iot.
-///
 /// \param[in] model Model object handle.
 /// \param[in] before CallBack before RunStep.
 /// \param[in] after CallBack after RunStep.
-///
 /// \return MSStatus.
 MS_API MSStatus MSModelRunStep(MSModelHandle model, const MSKernelCallBackC before, const MSKernelCallBackC after);
 
 /// \brief Set the model running mode. Only valid for Iot.
-///
 /// \param[in] model Model object handle.
 /// \param[in] train True means model runs in Train Mode, otherwise Eval Mode.
-///
 /// \return Status of operation.
 MS_API MSStatus MSModelSetTrainMode(const MSModelHandle model, bool train);
 
 /// \brief Export the weights of model to the binary file. Only valid for Iot.
-///
 /// \param[in] model Model object handle.
 /// \param[in] export_path Define the export weight file path.
-///
 /// \return Status of operation.
 MS_API MSStatus MSModelExportWeight(const MSModelHandle model, const char *export_path);
 
 /// \brief Obtain all input tensor handles of the model.
-///
 /// \param[in] model Model object handle.
-///
 /// \return The array that includes all input tensor handles.
 MS_API MSTensorHandleArray MSModelGetInputs(const MSModelHandle model);
 
 /// \brief Obtain all output tensor handles of the model.
-///
 /// \param[in] model Model object handle.
-///
 /// \return The array that includes all output tensor handles.
 MS_API MSTensorHandleArray MSModelGetOutputs(const MSModelHandle model);
 
 /// \brief Obtain the input tensor handle of the model by name.
-///
 /// \param[in] model Model object handle.
 /// \param[in] tensor_name The name of tensor.
-///
 /// \return The input tensor handle with the given name, if the name is not found, an NULL is returned.
 MS_API MSTensorHandle MSModelGetInputByTensorName(const MSModelHandle model, const char *tensor_name);
 
 /// \brief Obtain the output tensor handle of the model by name.
-///
 /// \param[in] model Model object handle.
 /// \param[in] tensor_name The name of tensor.
-///
 /// \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.
 ///
@@ -189,112 +160,88 @@ MS_API void MSTrainCfgDestroy(MSTrainCfgHandle *train_cfg);
 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.
@@ -303,14 +250,12 @@ MS_API MSStatus MSModelSetupVirtualBatch(MSModelHandle model, int virtual_batch_
 /// \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.
@@ -320,14 +265,12 @@ MS_API MSStatus MSExportModel(MSModelHandle model, MSModelType model_type, const
 /// \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.
@@ -335,7 +278,6 @@ MS_API MSStatus MSExportModelBuffer(MSModelHandle model, MSModelType model_type,
 /// \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,

mindspore/include/c_api/tensor_c.h

@@ -28,115 +28,89 @@ extern "C" {
 typedef void *MSTensorHandle;
 
 /// \brief Create a tensor object.
-///
 /// \param[in] name The name of the tensor.
 /// \param[in] type The data type of the tensor.
 /// \param[in] shape The shape of the tensor.
 /// \param[in] shape_num The num of the shape.
 /// \param[in] data The data pointer that points to allocated memory.
 /// \param[in] data_len The length of the memory, in bytes.
-///
 /// \return Tensor object handle.
 MS_API MSTensorHandle MSTensorCreate(const char *name, MSDataType type, const int64_t *shape, size_t shape_num,
                                      const void *data, size_t data_len);
 
 /// \brief Destroy the tensor object.
-///
 /// \param[in] tensor Tensor object handle address.
 MS_API void MSTensorDestroy(MSTensorHandle *tensor);
 
 /// \brief Obtain a deep copy of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return Tensor object handle.
 MS_API MSTensorHandle MSTensorClone(MSTensorHandle tensor);
 
 /// \brief Set the name for the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[in] name The name of the tensor.
 MS_API void MSTensorSetName(MSTensorHandle tensor, const char *name);
 
 /// \brief Obtain the name of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The name of the tensor.
 MS_API const char *MSTensorGetName(const MSTensorHandle tensor);
 
 /// \brief Set the data type for the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[in] type The data type of the tensor.
 MS_API void MSTensorSetDataType(MSTensorHandle tensor, MSDataType type);
 
 /// \brief Obtain the data type of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The date type of the tensor.
 MS_API MSDataType MSTensorGetDataType(const MSTensorHandle tensor);
 
 /// \brief Set the shape for the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[in] shape The shape array.
 /// \param[in] shape_num Dimension of shape.
 MS_API void MSTensorSetShape(MSTensorHandle tensor, const int64_t *shape, size_t shape_num);
 
 /// \brief Obtain the shape of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[out] shape_num Dimension of shape.
-///
 /// \return The shape array of the tensor.
 MS_API const int64_t *MSTensorGetShape(const MSTensorHandle tensor, size_t *shape_num);
 
 /// \brief Set the format for the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[in] format The format of the tensor.
 MS_API void MSTensorSetFormat(MSTensorHandle tensor, MSFormat format);
 
 /// \brief Obtain the format of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The format of the tensor.
 MS_API MSFormat MSTensorGetFormat(const MSTensorHandle tensor);
 
 /// \brief Obtain the data for the tensor.
-///
 /// \param[in] tensor Tensor object handle.
 /// \param[in] data A pointer to the data of the tensor.
 MS_API void MSTensorSetData(MSTensorHandle tensor, void *data);
 
 /// \brief Obtain the data pointer of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The data pointer of the tensor.
 MS_API const void *MSTensorGetData(const MSTensorHandle tensor);
 
 /// \brief Obtain the mutable data pointer of the tensor. If the internal data is empty, it will allocate memory.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The data pointer of the tensor.
 MS_API void *MSTensorGetMutableData(const MSTensorHandle tensor);
 
 /// \brief Obtain the element number of the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The element number of the tensor.
 MS_API int64_t MSTensorGetElementNum(const MSTensorHandle tensor);
 
 /// \brief Obtain the data size fo the tensor.
-///
 /// \param[in] tensor Tensor object handle.
-///
 /// \return The data size of the tensor.
 MS_API size_t MSTensorGetDataSize(const MSTensorHandle tensor);
 

mindspore/include/dataset/vision_ascend.h

@@ -31,7 +31,7 @@ namespace mindspore {
 namespace dataset {
 // Transform operations for performing computer vision.
 namespace vision {
-/* ##################################### API class ###########################################*/
+/* ##################################### API class ########################################### */
 
 /// \brief Decode and resize JPEG image using the hardware algorithm of
 ///     Ascend series chip DVPP module.