mindspore 2.6.0rc1__cp310-none-any.whl → 2.7.0rc1__cp310-none-any.whl

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_barrier.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_DIST_COMM_BARRIER_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_BARRIER_H_
+
+#include <vector>
+#include <memory>
+#include <tuple>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "runtime/hardware/device_context_manager.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+void DistCommBarrierCPUCustomize(const std::shared_ptr<OpRunner> &op, const StringImmPtr &group);
+
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_BARRIER_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_broadcast.h

@@ -28,8 +28,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void DistCommBroadcastCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &tensor,
-                                   const Int64ImmPtr &src, const Int64ImmPtr &rank_id, const StringImmPtr &group);
+void DistCommBroadcastCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &tensor, const Int64ImmPtr &src,
+                                   const Int64ImmPtr &rank_id, const StringImmPtr &group);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_gather.h

@@ -28,7 +28,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void DistCommGatherCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
+void DistCommGatherCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
                                 const ValueTuplePtr &gather_list, const Int64ImmPtr &rank_size, const Int64ImmPtr &dst,
                                 const Int64ImmPtr &rank_id, const StringImmPtr &group);
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_irecv.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_DIST_COMM_IRECV_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_IRECV_H_
+
+#include <vector>
+#include <memory>
+#include <tuple>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "runtime/hardware/device_context_manager.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+void DistCommIrecvCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                               const Int64ImmPtr &tag, const Int64ImmPtr &src, const StringImmPtr &group);
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_IRECV_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_isend.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_DIST_COMM_ISEND_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_ISEND_H_
+
+#include <vector>
+#include <memory>
+#include <tuple>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "runtime/hardware/device_context_manager.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+void DistCommIsendCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                               const Int64ImmPtr &dst, const StringImmPtr &group, const Int64ImmPtr &tag);
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_DIST_COMM_ISEND_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/dist_comm_scatter.h

@@ -28,7 +28,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void DistCommScatterCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &other_tensor,
+void DistCommScatterCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &other_tensor,
                                  const ValueTuplePtr &scatter_list, const Int64ImmPtr &rank_size,
                                  const Int64ImmPtr &src, const Int64ImmPtr &rank_id, const StringImmPtr &group);
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/divmod.h

@@ -27,9 +27,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr DivModCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor,
-                                         const BaseTensorPtr &y_tensor,
-                                         const std::optional<Int64ImmPtr> &rounding_mode);
+tensor::TensorPtr DivModCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor,
+                                     const TensorPtr &y_tensor, const std::optional<Int64ImmPtr> &rounding_mode);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/empty.h

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_EMPTY_ASCEND_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_EMPTY_ASCEND_H_
+
+#include <vector>
+#include <memory>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+tensor::TensorPtr EmptyCPUCustomize(const std::shared_ptr<OpRunner> &op, const ValueTuplePtr &size,
+                                    const std::optional<Int64ImmPtr> &dtype, const std::optional<Int64ImmPtr> &device);
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_EMPTY_ASCEND_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/empty_like.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_EMPTY_LIKE_ASCEND_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_EMPTY_LIKE_ASCEND_H_
+
+#include <memory>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "runtime/hardware/device_context_manager.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+tensor::TensorPtr EmptyLikeCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                        const std::optional<Int64ImmPtr> &dtype,
+                                        const std::optional<Int64ImmPtr> &device);
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_EMPTY_LIKE_ASCEND_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/group_norm.h

@@ -27,9 +27,9 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void GroupNormCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                           const Int64ImmPtr &num_groups, const std::optional<BaseTensorPtr> &weight_opt_tensor,
-                           const std::optional<BaseTensorPtr> &bias_opt_tensor, const FP32ImmPtr &eps);
+void GroupNormCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                           const Int64ImmPtr &num_groups, const std::optional<TensorPtr> &weight_opt_tensor,
+                           const std::optional<TensorPtr> &bias_opt_tensor, const FP32ImmPtr &eps);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/grouped_matmul.h

@@ -34,7 +34,7 @@ void GroupedMatmulCPUCustomize(const std::shared_ptr<OpRunner> &op, const ValueT
                                const std::optional<ValueTuplePtr> &offset_tensor_list,
                                const std::optional<ValueTuplePtr> &antiquant_scale_tensor_list,
                                const std::optional<ValueTuplePtr> &antiquant_offset_tensor_list,
-                               const std::optional<BaseTensorPtr> &group_list, const Int64ImmPtr &split_item,
+                               const std::optional<TensorPtr> &group_list, const Int64ImmPtr &split_item,
                                const Int64ImmPtr &group_type, const mindspore::BoolImmPtr &transpose_a,
                                const mindspore::BoolImmPtr &transpose_b);
 }  // namespace pyboost

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

@@ -26,7 +26,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr IdentityCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor);
+tensor::TensorPtr IdentityCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

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

@@ -27,9 +27,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr InnerCommAllReduceCPUCustomize(const std::shared_ptr<OpRunner> &op,
-                                                     const BaseTensorPtr &input_tensor, const StringImmPtr &op_type,
-                                                     const StringImmPtr &group);
+tensor::TensorPtr InnerCommAllReduceCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                                 const StringImmPtr &op_type, const StringImmPtr &group);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

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

@@ -27,8 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void InplaceCopyCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &variable,
-                             const BaseTensorPtr &value);
+void InplaceCopyCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &variable, const TensorPtr &value);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/layer_norm_ext.h

@@ -27,9 +27,9 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void LayerNormExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                              const ValueTuplePtr &normalized_shape, const std::optional<BaseTensorPtr> &weight_tensor,
-                              const std::optional<BaseTensorPtr> &bias_opt_tensor, const FP32ImmPtr &eps);
+void LayerNormExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                              const ValueTuplePtr &normalized_shape, const std::optional<TensorPtr> &weight_tensor,
+                              const std::optional<TensorPtr> &bias_opt_tensor, const FP32ImmPtr &eps);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/masked_select.h

@@ -27,8 +27,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr MaskedSelectCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                                               const BaseTensorPtr &mask_tensor);
+tensor::TensorPtr MaskedSelectCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                           const TensorPtr &mask_tensor);
 
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/matmul_ext.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void MatMulExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input, const BaseTensorPtr &other);
+void MatMulExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input, const TensorPtr &other);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/max.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void MaxCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor);
+void MaxCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/mean_ext.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void MeanExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor,
+void MeanExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor,
                          const std::optional<ValueTuplePtr> &axis, const BoolImmPtr &keep_dims,
                          const std::optional<Int64ImmPtr> &dtype);
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/meshgrid.h

@@ -27,8 +27,10 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-std::vector<tensor::BaseTensorPtr> MeshgridCPUCustomize(const std::shared_ptr<OpRunner> &op,
-                                                        const ValueTuplePtr &tensors_list, const Int64ImmPtr &indexing);
+std::vector<tensor::TensorPtr> MeshgridCPUCustomize(const std::shared_ptr<OpRunner> &op,
+                                                    const ValueTuplePtr &tensors_list, const Int64ImmPtr &indexing);
+std::vector<tensor::TensorPtr> MeshgridCPUCustomize(const std::shared_ptr<OpRunner> &op,
+                                                    const ValueTuplePtr &tensors_list, const int64_t &indexing);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/min.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void MinCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor);
+void MinCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/new_empty.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2025 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_CUSTOMIZE_NEW_EMPTY_ASCEND_H_
+#define MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_NEW_EMPTY_ASCEND_H_
+
+#include <vector>
+#include <memory>
+#include "ir/tensor.h"
+#include "ir/value.h"
+#include "mindspore/ccsrc/pyboost/op_runner.h"
+
+namespace mindspore {
+namespace kernel {
+namespace pyboost {
+tensor::TensorPtr NewEmptyCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                       const ValueTuplePtr &size, const std::optional<Int64ImmPtr> &dtype,
+                                       const std::optional<Int64ImmPtr> &device);
+}  // namespace pyboost
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_KERNEL_PYBOOST_CUSTOMIZE_NEW_EMPTY_ASCEND_H_

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/new_ones.h

@@ -26,8 +26,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void NewOnesCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                         const ValueTuplePtr &size, const std::optional<Int64ImmPtr> &dtype);
+void NewOnesCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor, const ValueTuplePtr &size,
+                         const std::optional<Int64ImmPtr> &dtype);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/new_zeros.h

@@ -26,8 +26,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void NewZerosCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                          const ValueTuplePtr &size, const std::optional<Int64ImmPtr> &dtype);
+void NewZerosCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor, const ValueTuplePtr &size,
+                          const std::optional<Int64ImmPtr> &dtype);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/non_zero.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr NonZeroCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor);
+tensor::TensorPtr NonZeroCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor);
 
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/pixel_shuffle.h

@@ -29,8 +29,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr PixelShuffleCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input,
-                                               const Int64ImmPtr &upscale_factor);
+tensor::TensorPtr PixelShuffleCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input,
+                                           const Int64ImmPtr &upscale_factor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/pow_scalar_tensor.h

@@ -27,7 +27,7 @@ namespace mindspore {
 namespace kernel {
 namespace pyboost {
 void PowScalarTensorCPUCustomize(const std::shared_ptr<OpRunner> &op, const ScalarPtr &input,
-                                 const BaseTensorPtr &exponent_tensor);
+                                 const TensorPtr &exponent_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/pow_tensor_scalar.h

@@ -26,7 +26,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void PowTensorScalarCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
+void PowTensorScalarCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
                                  const ScalarPtr &exponent);
 }  // namespace pyboost
 }  // namespace kernel

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/prod_ext.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void ProdExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor,
+void ProdExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor,
                          const std::optional<Int64ImmPtr> &axis, const BoolImmPtr &keep_dims,
                          const std::optional<Int64ImmPtr> &dtype);
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/reshape.h

@@ -27,8 +27,10 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr ReshapeCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor,
-                                          const ValueTuplePtr &shape);
+tensor::TensorPtr ReshapeCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                      const ValueTuplePtr &shape);
+tensor::TensorPtr ReshapeCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor,
+                                      const std::vector<int64_t> &shape);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/round.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void RoundCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input, const Int64ImmPtr &decimals);
+void RoundCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &input, const Int64ImmPtr &decimals);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/searchsorted.h

@@ -26,10 +26,9 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-tensor::BaseTensorPtr SearchSortedCPUCustomize(const std::shared_ptr<OpRunner> &op,
-                                               const BaseTensorPtr &sorted_sequence, const BaseTensorPtr &values,
-                                               const std::optional<BaseTensorPtr> &sorter, const Int64ImmPtr &dtype,
-                                               const BoolImmPtr &right);
+tensor::TensorPtr SearchSortedCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &sorted_sequence,
+                                           const TensorPtr &values, const std::optional<TensorPtr> &sorter,
+                                           const Int64ImmPtr &dtype, const BoolImmPtr &right);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/silu.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void SiLUCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor);
+void SiLUCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/silu_grad.h

@@ -27,8 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void SiLUGradCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &dout_tensor,
-                          const BaseTensorPtr &x_tensor);
+void SiLUGradCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &dout_tensor, const TensorPtr &x_tensor);
 }  // namespace pyboost
 }  // namespace kernel
 }  // namespace mindspore

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/sum_ext.h

@@ -27,7 +27,7 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-void SumExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &x_tensor,
+void SumExtCPUCustomize(const std::shared_ptr<OpRunner> &op, const TensorPtr &x_tensor,
                         const std::optional<ValueTuplePtr> &axis, const BoolImmPtr &keep_dims,
                         const std::optional<Int64ImmPtr> &dtype);
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/pyboost/customize/unique_consecutive.h

@@ -28,8 +28,8 @@
 namespace mindspore {
 namespace kernel {
 namespace pyboost {
-std::tuple<tensor::BaseTensorPtr, tensor::BaseTensorPtr, tensor::BaseTensorPtr> UniqueConsecutiveCPUCustomize(
-  const std::shared_ptr<OpRunner> &op, const BaseTensorPtr &input_tensor, const BoolImmPtr &return_inverse,
+std::tuple<tensor::TensorPtr, tensor::TensorPtr, tensor::TensorPtr> UniqueConsecutiveCPUCustomize(
+  const std::shared_ptr<OpRunner> &op, const TensorPtr &input_tensor, const BoolImmPtr &return_inverse,
   const BoolImmPtr &return_counts, const std::optional<Int64ImmPtr> &dim);
 
 }  // namespace pyboost

mindspore/include/mindspore/ops/kernel/cpu/sequence/sequence_len_cpu_kernel.h

@@ -45,7 +45,6 @@ class SequenceLenCpuKernelMod : public NativeCpuKernelMod, public MatchKernelHel
  protected:
   std::vector<KernelAttr> GetOpSupport() override { return OpSupport(); }
 
-  template <typename T>
   bool LaunchKernel(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
                     const std::vector<KernelTensor *> &outputs);
 

mindspore/include/mindspore/ops/kernel/cpu/sparse_apply_adagrad_cpu_kernel.h

@@ -49,7 +49,7 @@ class SparseApplyAdagradCpuKernelMod : public sparse_optimizer_cpu::SparseOptimi
   void ResetResource() noexcept;
 
  protected:
-  float lr_;
+  float lr_{0};
   bool update_slots_{true};
 
  private:

mindspore/include/mindspore/ops/kernel/cpu/sparse_apply_adagrad_v2_cpu_kernel.h

@@ -47,8 +47,8 @@ class SparseApplyAdagradV2CpuKernelMod : public sparse_optimizer_cpu::SparseOpti
   void ResetResource() noexcept;
 
  protected:
-  float lr_;
-  float epsilon_;
+  float lr_{0};
+  float epsilon_{0};
   bool update_slots_{true};
 
  private: