mindspore 2.6.0__cp39-none-any.whl → 2.7.0rc1__cp39-none-any.whl

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/hswish_grad.h

@@ -30,7 +30,7 @@ class HSwishGradCPU : public pyboost::HSwishGrad {
     : HSwishGrad(std::move(primitive), device_context) {}
   ~HSwishGradCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &y_grad_tensor, const mindspore::tensor::BaseTensorPtr &x_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &y_grad_tensor, const mindspore::tensor::TensorPtr &x_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/identity.h

@@ -30,7 +30,7 @@ class IdentityCPU : public pyboost::Identity {
     : Identity(std::move(primitive), device_context) {}
   ~IdentityCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_x_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_x_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/im2col_ext.h

@@ -30,7 +30,7 @@ class Im2ColExtCPU : public pyboost::Im2ColExt {
     : Im2ColExt(std::move(primitive), device_context) {}
   ~Im2ColExtCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &kernel_size, const mindspore::ValueTuplePtr &dilation, const mindspore::ValueTuplePtr &padding, const mindspore::ValueTuplePtr &stride) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &kernel_size, const mindspore::ValueTuplePtr &dilation, const mindspore::ValueTuplePtr &padding, const mindspore::ValueTuplePtr &stride) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/incre_flash_attention.h

@@ -30,7 +30,7 @@ class IncreFlashAttentionCPU : public pyboost::IncreFlashAttention {
     : IncreFlashAttention(std::move(primitive), device_context) {}
   ~IncreFlashAttentionCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &query_tensor, const mindspore::ValueTuplePtr &key_tensor_list, const mindspore::ValueTuplePtr &value_tensor_list, const std::optional<mindspore::tensor::BaseTensorPtr> &attn_mask_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &actual_seq_lengths_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &pse_shift_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &dequant_scale1_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &quant_scale1_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &dequant_scale2_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &quant_scale2_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &quant_offset2_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &antiquant_scale_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &antiquant_offset_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &block_table_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &kv_padding_size_tensor, const mindspore::Int64ImmPtr &num_heads, const mindspore::Int64ImmPtr &input_layout, const mindspore::FP32ImmPtr &scale_value, const mindspore::Int64ImmPtr &num_key_value_heads, const mindspore::Int64ImmPtr &block_size, const mindspore::Int64ImmPtr &inner_precise) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &query_tensor, const mindspore::ValueTuplePtr &key_tensor_list, const mindspore::ValueTuplePtr &value_tensor_list, const std::optional<mindspore::tensor::TensorPtr> &attn_mask_tensor, const std::optional<mindspore::tensor::TensorPtr> &actual_seq_lengths_tensor, const std::optional<mindspore::tensor::TensorPtr> &pse_shift_tensor, const std::optional<mindspore::tensor::TensorPtr> &dequant_scale1_tensor, const std::optional<mindspore::tensor::TensorPtr> &quant_scale1_tensor, const std::optional<mindspore::tensor::TensorPtr> &dequant_scale2_tensor, const std::optional<mindspore::tensor::TensorPtr> &quant_scale2_tensor, const std::optional<mindspore::tensor::TensorPtr> &quant_offset2_tensor, const std::optional<mindspore::tensor::TensorPtr> &antiquant_scale_tensor, const std::optional<mindspore::tensor::TensorPtr> &antiquant_offset_tensor, const std::optional<mindspore::tensor::TensorPtr> &block_table_tensor, const std::optional<mindspore::tensor::TensorPtr> &kv_padding_size_tensor, const mindspore::Int64ImmPtr &num_heads, const mindspore::Int64ImmPtr &input_layout, const mindspore::FP32ImmPtr &scale_value, const mindspore::Int64ImmPtr &num_key_value_heads, const mindspore::Int64ImmPtr &block_size, const mindspore::Int64ImmPtr &inner_precise) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/index.h

@@ -30,7 +30,7 @@ class IndexCPU : public pyboost::Index {
     : Index(std::move(primitive), device_context) {}
   ~IndexCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/index_add_ext.h

@@ -30,7 +30,7 @@ class IndexAddExtCPU : public pyboost::IndexAddExt {
     : IndexAddExt(std::move(primitive), device_context) {}
   ~IndexAddExtCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &source_tensor, const mindspore::ScalarPtr &alpha) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &source_tensor, const mindspore::ScalarPtr &alpha) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/index_fill_scalar.h

@@ -30,7 +30,7 @@ class IndexFillScalarCPU : public pyboost::IndexFillScalar {
     : IndexFillScalar(std::move(primitive), device_context) {}
   ~IndexFillScalarCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::ScalarPtr &value) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::ScalarPtr &value) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/index_fill_tensor.h

@@ -30,7 +30,7 @@ class IndexFillTensorCPU : public pyboost::IndexFillTensor {
     : IndexFillTensor(std::move(primitive), device_context) {}
   ~IndexFillTensorCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &value_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &value_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_all_gather.h

@@ -30,7 +30,7 @@ class InnerCommAllGatherCPU : public pyboost::InnerCommAllGather {
     : InnerCommAllGather(std::move(primitive), device_context) {}
   ~InnerCommAllGatherCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &rank_size, const mindspore::StringImmPtr &group) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &rank_size, const mindspore::StringImmPtr &group) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_all_reduce.h

@@ -30,7 +30,7 @@ class InnerCommAllReduceCPU : public pyboost::InnerCommAllReduce {
     : InnerCommAllReduce(std::move(primitive), device_context) {}
   ~InnerCommAllReduceCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::StringImmPtr &op_type, const mindspore::StringImmPtr &group) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::StringImmPtr &op_type, const mindspore::StringImmPtr &group) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_all_to_all_v.h

@@ -30,7 +30,7 @@ class InnerCommAllToAllVCPU : public pyboost::InnerCommAllToAllV {
     : InnerCommAllToAllV(std::move(primitive), device_context) {}
   ~InnerCommAllToAllVCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::StringImmPtr &group, const mindspore::ValueTuplePtr &send_numel_list, const mindspore::ValueTuplePtr &recv_numel_list, const mindspore::Int64ImmPtr &rank_size, const mindspore::BoolImmPtr &split_sizes_empty) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::StringImmPtr &group, const mindspore::ValueTuplePtr &send_numel_list, const mindspore::ValueTuplePtr &recv_numel_list, const mindspore::Int64ImmPtr &rank_size, const mindspore::BoolImmPtr &split_sizes_empty) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_irecv.h

@@ -30,7 +30,7 @@ class InnerCommIrecvCPU : public pyboost::InnerCommIrecv {
     : InnerCommIrecv(std::move(primitive), device_context) {}
   ~InnerCommIrecvCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::Int64ImmPtr &tag, const mindspore::Int64ImmPtr &src, const mindspore::ValueTuplePtr &shape, const mindspore::StringImmPtr &group, const mindspore::Int64ImmPtr &dtype) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::Int64ImmPtr &tag, const mindspore::Int64ImmPtr &src, const mindspore::ValueTuplePtr &shape, const mindspore::StringImmPtr &group, const mindspore::Int64ImmPtr &dtype) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_isend.h

@@ -30,7 +30,7 @@ class InnerCommIsendCPU : public pyboost::InnerCommIsend {
     : InnerCommIsend(std::move(primitive), device_context) {}
   ~InnerCommIsendCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dst, const mindspore::StringImmPtr &group, const mindspore::Int64ImmPtr &tag) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dst, const mindspore::StringImmPtr &group, const mindspore::Int64ImmPtr &tag) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_comm_reduce_scatter.h

@@ -30,7 +30,7 @@ class InnerCommReduceScatterCPU : public pyboost::InnerCommReduceScatter {
     : InnerCommReduceScatter(std::move(primitive), device_context) {}
   ~InnerCommReduceScatterCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &rank_size, const mindspore::StringImmPtr &op_type, const mindspore::StringImmPtr &group) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &rank_size, const mindspore::StringImmPtr &op_type, const mindspore::StringImmPtr &group) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_index.h

@@ -30,7 +30,7 @@ class InnerIndexCPU : public pyboost::InnerIndex {
     : InnerIndex(std::move(primitive), device_context) {}
   ~InnerIndexCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_inplace_index_put.h

@@ -30,7 +30,7 @@ class InnerInplaceIndexPutCPU : public pyboost::InnerInplaceIndexPut {
     : InnerInplaceIndexPut(std::move(primitive), device_context) {}
   ~InnerInplaceIndexPutCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list, const mindspore::tensor::BaseTensorPtr &values_tensor, const mindspore::BoolImmPtr &accumulate) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list, const mindspore::tensor::TensorPtr &values_tensor, const mindspore::BoolImmPtr &accumulate) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_moe_token_unpermute.h

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INNERMOETOKENUNPERMUTE_CPU_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INNERMOETOKENUNPERMUTE_CPU_H_
+
+#include "mindspore/ccsrc/pyboost/auto_generate/inner_moe_token_unpermute.h"
+#include "ir/tensor.h"
+#include "ir/scalar.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+class InnerMoeTokenUnpermuteCPU : public pyboost::InnerMoeTokenUnpermute {
+ public:
+  InnerMoeTokenUnpermuteCPU(PrimitivePtr primitive, const DeviceContext *device_context)
+    : InnerMoeTokenUnpermute(std::move(primitive), device_context) {}
+  ~InnerMoeTokenUnpermuteCPU() = default;
+
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &permuted_tokens_tensor, const mindspore::tensor::TensorPtr &sorted_indices_tensor, const std::optional<mindspore::tensor::TensorPtr> &probs_tensor, const mindspore::BoolImmPtr &padded_mode, const std::optional<mindspore::ValueTuplePtr> &restore_shape) override;
+};
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INNERMOETOKENUNPERMUTE_CPU_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inner_non_zero.h

@@ -30,7 +30,7 @@ class InnerNonZeroCPU : public pyboost::InnerNonZero {
     : InnerNonZero(std::move(primitive), device_context) {}
   ~InnerNonZeroCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_addmm.h

@@ -30,7 +30,7 @@ class InplaceAddmmCPU : public pyboost::InplaceAddmm {
     : InplaceAddmm(std::move(primitive), device_context) {}
   ~InplaceAddmmCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &mat1_tensor, const mindspore::tensor::BaseTensorPtr &mat2_tensor, const mindspore::ScalarPtr &beta, const mindspore::ScalarPtr &alpha) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &mat1_tensor, const mindspore::tensor::TensorPtr &mat2_tensor, const mindspore::ScalarPtr &beta, const mindspore::ScalarPtr &alpha) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_clamp_scalar.h

@@ -30,7 +30,7 @@ class InplaceClampScalarCPU : public pyboost::InplaceClampScalar {
     : InplaceClampScalar(std::move(primitive), device_context) {}
   ~InplaceClampScalarCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const std::optional<mindspore::ScalarPtr> &min, const std::optional<mindspore::ScalarPtr> &max) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const std::optional<mindspore::ScalarPtr> &min, const std::optional<mindspore::ScalarPtr> &max) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_clamp_tensor.h

@@ -30,7 +30,7 @@ class InplaceClampTensorCPU : public pyboost::InplaceClampTensor {
     : InplaceClampTensor(std::move(primitive), device_context) {}
   ~InplaceClampTensorCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &min_tensor, const std::optional<mindspore::tensor::BaseTensorPtr> &max_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const std::optional<mindspore::tensor::TensorPtr> &min_tensor, const std::optional<mindspore::tensor::TensorPtr> &max_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_copy.h

@@ -30,7 +30,7 @@ class InplaceCopyCPU : public pyboost::InplaceCopy {
     : InplaceCopy(std::move(primitive), device_context) {}
   ~InplaceCopyCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &src_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &src_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_div.h

@@ -30,7 +30,7 @@ class InplaceDivCPU : public pyboost::InplaceDiv {
     : InplaceDiv(std::move(primitive), device_context) {}
   ~InplaceDivCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &other_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &other_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_divmod.h

@@ -30,7 +30,7 @@ class InplaceDivModCPU : public pyboost::InplaceDivMod {
     : InplaceDivMod(std::move(primitive), device_context) {}
   ~InplaceDivModCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &other_tensor, const std::optional<mindspore::Int64ImmPtr> &rounding_mode) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &other_tensor, const std::optional<mindspore::Int64ImmPtr> &rounding_mode) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_divmods.h

@@ -30,7 +30,7 @@ class InplaceDivModsCPU : public pyboost::InplaceDivMods {
     : InplaceDivMods(std::move(primitive), device_context) {}
   ~InplaceDivModsCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &other, const std::optional<mindspore::Int64ImmPtr> &rounding_mode) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &other, const std::optional<mindspore::Int64ImmPtr> &rounding_mode) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_divs.h

@@ -30,7 +30,7 @@ class InplaceDivsCPU : public pyboost::InplaceDivs {
     : InplaceDivs(std::move(primitive), device_context) {}
   ~InplaceDivsCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_elu.h

@@ -30,7 +30,7 @@ class InplaceEluCPU : public pyboost::InplaceElu {
     : InplaceElu(std::move(primitive), device_context) {}
   ~InplaceEluCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::FP32ImmPtr &alpha) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::FP32ImmPtr &alpha) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_erfinv.h

@@ -30,7 +30,7 @@ class InplaceErfinvCPU : public pyboost::InplaceErfinv {
     : InplaceErfinv(std::move(primitive), device_context) {}
   ~InplaceErfinvCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_exponential.h

@@ -30,7 +30,7 @@ class InplaceExponentialCPU : public pyboost::InplaceExponential {
     : InplaceExponential(std::move(primitive), device_context) {}
   ~InplaceExponentialCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &lambd, const mindspore::tensor::BaseTensorPtr &seed_tensor, const mindspore::tensor::BaseTensorPtr &offset_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &lambd, const mindspore::tensor::TensorPtr &seed_tensor, const mindspore::tensor::TensorPtr &offset_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_fill_diagonal.h

@@ -30,7 +30,7 @@ class InplaceFillDiagonalCPU : public pyboost::InplaceFillDiagonal {
     : InplaceFillDiagonal(std::move(primitive), device_context) {}
   ~InplaceFillDiagonalCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &fill_value, const mindspore::BoolImmPtr &wrap) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &fill_value, const mindspore::BoolImmPtr &wrap) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_fill_scalar.h

@@ -30,7 +30,7 @@ class InplaceFillScalarCPU : public pyboost::InplaceFillScalar {
     : InplaceFillScalar(std::move(primitive), device_context) {}
   ~InplaceFillScalarCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &value) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &value) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_fill_tensor.h

@@ -30,7 +30,7 @@ class InplaceFillTensorCPU : public pyboost::InplaceFillTensor {
     : InplaceFillTensor(std::move(primitive), device_context) {}
   ~InplaceFillTensorCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &value_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &value_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_floor.h

@@ -30,7 +30,7 @@ class InplaceFloorCPU : public pyboost::InplaceFloor {
     : InplaceFloor(std::move(primitive), device_context) {}
   ~InplaceFloorCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_floor_divide.h

@@ -30,7 +30,7 @@ class InplaceFloorDivideCPU : public pyboost::InplaceFloorDivide {
     : InplaceFloorDivide(std::move(primitive), device_context) {}
   ~InplaceFloorDivideCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &other_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &other_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_floor_divides.h

@@ -30,7 +30,7 @@ class InplaceFloorDividesCPU : public pyboost::InplaceFloorDivides {
     : InplaceFloorDivides(std::move(primitive), device_context) {}
   ~InplaceFloorDividesCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_grouped_matmul_add.h

@@ -30,7 +30,7 @@ class InplaceGroupedMatmulAddCPU : public pyboost::InplaceGroupedMatmulAdd {
     : InplaceGroupedMatmulAdd(std::move(primitive), device_context) {}
   ~InplaceGroupedMatmulAddCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &x_tensor, const mindspore::tensor::BaseTensorPtr &weight_tensor, const mindspore::tensor::BaseTensorPtr &group_list_tensor, const mindspore::tensor::BaseTensorPtr &out_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &x_tensor, const mindspore::tensor::TensorPtr &weight_tensor, const mindspore::tensor::TensorPtr &group_list_tensor, const mindspore::tensor::TensorPtr &out_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_hardtanh.h

@@ -30,7 +30,7 @@ class InplaceHardtanhCPU : public pyboost::InplaceHardtanh {
     : InplaceHardtanh(std::move(primitive), device_context) {}
   ~InplaceHardtanhCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &min_val, const mindspore::ScalarPtr &max_val) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &min_val, const mindspore::ScalarPtr &max_val) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_index_add.h

@@ -30,7 +30,7 @@ class InplaceIndexAddExtCPU : public pyboost::InplaceIndexAddExt {
     : InplaceIndexAddExt(std::move(primitive), device_context) {}
   ~InplaceIndexAddExtCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &source_tensor, const mindspore::ScalarPtr &alpha) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &source_tensor, const mindspore::ScalarPtr &alpha) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_index_put.h

@@ -30,7 +30,7 @@ class InplaceIndexPutCPU : public pyboost::InplaceIndexPut {
     : InplaceIndexPut(std::move(primitive), device_context) {}
   ~InplaceIndexPutCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list, const mindspore::tensor::BaseTensorPtr &values_tensor, const mindspore::BoolImmPtr &accumulate) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &indices_tensor_list, const mindspore::tensor::TensorPtr &values_tensor, const mindspore::BoolImmPtr &accumulate) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_log.h

@@ -30,7 +30,7 @@ class InplaceLogCPU : public pyboost::InplaceLog {
     : InplaceLog(std::move(primitive), device_context) {}
   ~InplaceLogCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_masked_fill_scalar.h

@@ -30,7 +30,7 @@ class InplaceMaskedFillScalarCPU : public pyboost::InplaceMaskedFillScalar {
     : InplaceMaskedFillScalar(std::move(primitive), device_context) {}
   ~InplaceMaskedFillScalarCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &mask_tensor, const mindspore::ScalarPtr &value) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &mask_tensor, const mindspore::ScalarPtr &value) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_masked_fill_tensor.h

@@ -30,7 +30,7 @@ class InplaceMaskedFillTensorCPU : public pyboost::InplaceMaskedFillTensor {
     : InplaceMaskedFillTensor(std::move(primitive), device_context) {}
   ~InplaceMaskedFillTensorCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &mask_tensor, const mindspore::tensor::BaseTensorPtr &value_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &mask_tensor, const mindspore::tensor::TensorPtr &value_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_matmul_add.h

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ */
+
+#ifndef MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INPLACEMATMULADD_CPU_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INPLACEMATMULADD_CPU_H_
+
+#include "mindspore/ccsrc/pyboost/auto_generate/inplace_matmul_add.h"
+#include "ir/tensor.h"
+#include "ir/scalar.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+class InplaceMatmulAddCPU : public pyboost::InplaceMatmulAdd {
+ public:
+  InplaceMatmulAddCPU(PrimitivePtr primitive, const DeviceContext *device_context)
+    : InplaceMatmulAdd(std::move(primitive), device_context) {}
+  ~InplaceMatmulAddCPU() = default;
+
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &x_tensor, const mindspore::tensor::TensorPtr &weight_tensor, const mindspore::tensor::TensorPtr &C_tensor) override;
+};
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_INPLACEMATMULADD_CPU_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_mul.h

@@ -30,7 +30,7 @@ class InplaceMulCPU : public pyboost::InplaceMul {
     : InplaceMul(std::move(primitive), device_context) {}
   ~InplaceMulCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &other_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &other_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_muls.h

@@ -30,7 +30,7 @@ class InplaceMulsCPU : public pyboost::InplaceMuls {
     : InplaceMuls(std::move(primitive), device_context) {}
   ~InplaceMulsCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &other) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_normal.h

@@ -30,7 +30,7 @@ class InplaceNormalCPU : public pyboost::InplaceNormal {
     : InplaceNormal(std::move(primitive), device_context) {}
   ~InplaceNormalCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ScalarPtr &mean, const mindspore::ScalarPtr &std, const mindspore::tensor::BaseTensorPtr &seed_tensor, const mindspore::tensor::BaseTensorPtr &offset_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ScalarPtr &mean, const mindspore::ScalarPtr &std, const mindspore::tensor::TensorPtr &seed_tensor, const mindspore::tensor::TensorPtr &offset_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_put.h

@@ -30,7 +30,7 @@ class InplacePutCPU : public pyboost::InplacePut {
     : InplacePut(std::move(primitive), device_context) {}
   ~InplacePutCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &source_tensor, const mindspore::BoolImmPtr &accumulate) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &source_tensor, const mindspore::BoolImmPtr &accumulate) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_random.h

@@ -30,7 +30,7 @@ class InplaceRandomCPU : public pyboost::InplaceRandom {
     : InplaceRandom(std::move(primitive), device_context) {}
   ~InplaceRandomCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &from_, const std::optional<mindspore::Int64ImmPtr> &to, const mindspore::tensor::BaseTensorPtr &seed_tensor, const mindspore::tensor::BaseTensorPtr &offset_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &from_, const std::optional<mindspore::Int64ImmPtr> &to, const mindspore::tensor::TensorPtr &seed_tensor, const mindspore::tensor::TensorPtr &offset_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_relu.h

@@ -30,7 +30,7 @@ class InplaceReLUCPU : public pyboost::InplaceReLU {
     : InplaceReLU(std::move(primitive), device_context) {}
   ~InplaceReLUCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_scatter_add.h

@@ -30,7 +30,7 @@ class InplaceScatterAddCPU : public pyboost::InplaceScatterAdd {
     : InplaceScatterAdd(std::move(primitive), device_context) {}
   ~InplaceScatterAddCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &src_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &src_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/auto_generate/inplace_scatter_src.h

@@ -30,7 +30,7 @@ class InplaceScatterSrcCPU : public pyboost::InplaceScatterSrc {
     : InplaceScatterSrc(std::move(primitive), device_context) {}
   ~InplaceScatterSrcCPU() = default;
 
-  mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::BaseTensorPtr &index_tensor, const mindspore::tensor::BaseTensorPtr &src_tensor) override;
+  mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::Int64ImmPtr &dim, const mindspore::tensor::TensorPtr &index_tensor, const mindspore::tensor::TensorPtr &src_tensor) override;
 };
 }  // namespace pyboost
 }  // namespace kernel