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

mindspore/include/mindspore/ccsrc/pybind_api/ir/tensor_index_py.h

@@ -78,8 +78,8 @@ class Slice final {
  public:
   Slice(const py::object &start_index, const py::object &stop_index, const py::object &step_index) {
     dim_size_ = kIndexMax;
-    if (IsTensorPy(step_index) || IsStubTensor(step_index)) {
-      auto step_tensor = IsStubTensor(step_index) ? ConvertStubTensor(step_index) : ConvertToTensor(step_index);
+    if (IsTensorPy(step_index)) {
+      auto step_tensor = ConvertToTensor(step_index);
       MS_EXCEPTION_IF_NULL(step_tensor);
       if (step_tensor->data_type() == kMetaTypeNone) {
         step_ = 1;
@@ -197,9 +197,6 @@ class Slice final {
       auto tensor_index = ConvertToTensor(index);
       MS_EXCEPTION_IF_NULL(tensor_index);
       return tensor_index->data_type() == kMetaTypeNone;
-    } else if (IsStubTensor(index)) {
-      auto type_id = GetStubTensorInfo(index).second->type_id();
-      return type_id == kMetaTypeNone;
     } else if (py::isinstance<py::none>(index)) {
       return true;
     }
@@ -208,8 +205,8 @@ class Slice final {
 
   static inline int64_t NormalizeIndex(const py::object &index, int64_t step, int64_t dim_size) {
     int64_t normalized_index;
-    if (IsTensorPy(index) || IsStubTensor(index)) {
-      auto tensor_index = IsStubTensor(index) ? ConvertStubTensor(index) : ConvertToTensor(index);
+    if (IsTensorPy(index)) {
+      auto tensor_index = ConvertToTensor(index);
       MS_EXCEPTION_IF_NULL(tensor_index);
       normalized_index = NormalizeIndex(tensor_index, step, dim_size);
     } else if (py::isinstance<py::int_>(index)) {
@@ -256,40 +253,7 @@ class TensorIndex final {
   explicit TensorIndex(float float_input) : float_(float_input), type_(TensorIndexType::Float) {}
   explicit TensorIndex(const py::float_ &float_input) : TensorIndex(float_input.cast<float>()) {}
 
-  explicit TensorIndex(const py::handle &py_object) {
-    if (py::isinstance<py::list>(py_object)) {
-      this->list_ = py_object.cast<py::list>();
-      this->type_ = TensorIndexType::List;
-    } else if (py::isinstance<py::int_>(py_object) && !py::isinstance<py::bool_>(py_object)) {
-      this->integer_ = py_object.cast<py::int_>();
-      this->type_ = TensorIndexType::Integer;
-    } else if (py::isinstance<py::float_>(py_object)) {
-      this->float_ = py_object.cast<py::float_>();
-      this->type_ = TensorIndexType::Float;
-    } else if (py::isinstance<py::tuple>(py_object)) {
-      this->tuple_ = py_object.cast<py::tuple>();
-      this->type_ = TensorIndexType::Tuple;
-    } else if (py::isinstance<py::slice>(py_object)) {
-      this->slice_ = TensorIndex(py_object.cast<py::slice>()).slice_;
-      this->type_ = TensorIndexType::Slice;
-    } else if (py::isinstance<py::ellipsis>(py_object)) {
-      this->type_ = TensorIndexType::Ellipsis;
-    } else if (py::isinstance<py::none>(py_object)) {
-      this->type_ = TensorIndexType::None;
-    } else if (py::isinstance<py::array>(py_object)) {
-      this->array_ = py_object.cast<py::array>();
-      this->type_ = TensorIndexType::Array;
-    } else if (py::isinstance<py::bool_>(py_object)) {
-      this->boolean_ = py_object.cast<py::bool_>();
-      this->type_ = TensorIndexType::Boolean;
-    } else if (IsStubTensor(py_object)) {
-      this->tensorpynew_ = ConvertPyObject2StubTensor(py_object);
-      this->type_ = TensorIndexType::Tensor;
-    } else if (IsTensorPy(py_object)) {
-      this->tensorpynew_ = py_object;
-      this->type_ = TensorIndexType::Tensor;
-    }
-  }
+  explicit TensorIndex(const py::handle &py_object);
 
   inline bool IsNone() const { return type_ == TensorIndexType::None; }
 
@@ -411,28 +375,8 @@ class TensorIndex final {
     return out;
   }
   static ShapeVector BroadCastShape(const ShapeVector &x_shape, const ShapeVector &y_shape);
-  static ShapeVector BroadCastShape(const std::vector<ShapeVector> &tensor_indexes_shapes) {
-    if (tensor_indexes_shapes.empty()) {
-      return {};
-    }
-    return std::accumulate(tensor_indexes_shapes.begin(), tensor_indexes_shapes.end(), tensor_indexes_shapes[0],
-                           [](const auto &output_shape, const auto &tensor_indexes_shape) {
-                             return BroadCastShape(output_shape, tensor_indexes_shape);
-                           });
-  }
-  static std::vector<int64_t> SliceToVector(int64_t start, int64_t stop, int64_t step) {
-    std::vector<int64_t> slice_ele_list_index;
-    if (step > 0) {
-      for (int64_t j = start; j < stop; j += step) {
-        (void)slice_ele_list_index.emplace_back(j);
-      }
-      return slice_ele_list_index;
-    }
-    for (int64_t j = start; j > stop; j += step) {
-      (void)slice_ele_list_index.emplace_back(j);
-    }
-    return slice_ele_list_index;
-  }
+  static ShapeVector BroadCastShape(const std::vector<ShapeVector> &tensor_indexes_shapes);
+  static std::vector<int64_t> SliceToVector(int64_t start, int64_t stop, int64_t step);
 
   // This is the c++ version of sequence_to_index in
   // "mindspore/python/mindspore/ops/composite/multitype_ops/_constexpr_utils.py"
@@ -460,20 +404,7 @@ class TensorIndex final {
     return (dim_size + (x % dim_size)) % dim_size;
   }
 
-  static bool CheckScalarValue(const py::handle &value) {
-    if (IsTensorPy(value)) {
-      TensorPtr data = ConvertToTensor(value);
-      MS_EXCEPTION_IF_NULL(data);
-      auto data_shape = data->shape();
-      return data_shape.empty();
-    }
-    if (IsStubTensor(value)) {
-      auto data_shape = GetStubTensorInfo(value).first;
-      return data_shape.empty();
-    }
-    return CheckTypeIsInstance(TensorIndex(value).type(),
-                               {TensorIndexType::Float, TensorIndexType::Integer, TensorIndexType::Boolean});
-  }
+  static bool CheckScalarValue(const py::handle &value);
 
   static py::object DeepList(const py::object &array_like, int64_t dim_size);
   static py::object DeepTensorToNdArray(const py::object &array_like);
@@ -500,36 +431,10 @@ class TensorIndex final {
                                   int64_t fancy_position);
 
   static ShapeVector ComputeSliceShape(const ShapeVector &slice_shape, size_t broadcast_shape_len, size_t slice_cnt,
-                                       int64_t fancy_position) {
-    ShapeVector shape(slice_shape.size(), 1);
-    if (slice_cnt >= shape.size()) {
-      MS_EXCEPTION(IndexError) << "Index out of shape size.";
-    }
-    shape[slice_cnt] = slice_shape[slice_cnt];
-    ShapeVector temp_shape(broadcast_shape_len, 1);
-    (void)shape.insert(shape.begin() + fancy_position, temp_shape.begin(), temp_shape.end());
-    return shape;
-  }
+                                       int64_t fancy_position);
 
-  static ShapeVector ComputeMultiples(const ShapeVector &origin_shape, const ShapeVector &broadcast_shape) {
-    int64_t len_gap = SizeToLong(broadcast_shape.size()) - SizeToLong(origin_shape.size());
-    ShapeVector output_shape = broadcast_shape;
-    (void)std::transform(broadcast_shape.begin() + len_gap, broadcast_shape.end(), origin_shape.begin(),
-                         output_shape.begin() + len_gap, [](int64_t x, int64_t y) {
-                           MS_EXCEPTION_IF_ZERO("dim of data shape", y);
-                           return x / y;
-                         });
-    return output_shape;
-  }
+  static ShapeVector GeneratePaddingShape(const ShapeVector &shape, int64_t length);
 
-  static ShapeVector GeneratePaddingShape(const ShapeVector &shape, int64_t length) {
-    if (SizeToLong(shape.size()) > length) {
-      MS_EXCEPTION(ValueError) << "Can not pad " << shape << " to length " << length;
-    }
-    ShapeVector pad_shape(length - SizeToLong(shape.size()), 1);
-    (void)pad_shape.insert(pad_shape.begin(), shape.begin(), shape.end());
-    return pad_shape;
-  }
   static py::object BroadCastTo(const ShapeVector &broadcast_shape, const py::object &item);
 
   // This is the c++ version of _transform_indexing_tensor in
@@ -683,8 +588,6 @@ class TensorIndex final {
 
   friend std::ostream &operator<<(std::ostream &stream, const TensorIndex &tensor_index);
   friend std::ostream &operator<<(std::ostream &stream, const std::vector<TensorIndex> &tensor_indices);
-
-  static const py::handle ConvertPyObject2StubTensor(const py::handle &obj);
 };
 }  // namespace tensor
 }  // namespace mindspore

mindspore/include/mindspore/ccsrc/pybind_api/ir/tensor_register/auto_generate/tensor_py_gen.h

@@ -57,161 +57,163 @@ namespace tensor {
 
 
 #define DEFINE_TENSOR_METHODS_CPYWRAPPERS()         \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logsumexp) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(RepeatInterleave) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalXor) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewZeros) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(NotEqual) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Div_) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Addbmm) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Scatter_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(ExpandAs) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Neg) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Matmul) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log_) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Lerp) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Var) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalNot) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cosh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Scatter) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tanh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mul) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isneginf) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(All) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedFill_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addcdiv) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Triu) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Dot) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(FloorDivide_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Minimum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tan) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Eq) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Isclose) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Less) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Histc) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Maximum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addmv) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log10) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Unbind) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Exp_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Xlogy) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sqrt) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Min) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Kthvalue) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argsort) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Max) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sum) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isneginf) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(FillDiagonal_) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Roll) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Trunc) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sinh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Diag) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Inverse) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Ceil) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(NanToNum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseAnd) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Repeat) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(FloorDivide) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tile) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cosh) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Add_) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseXor) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argmin) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logaddexp2) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Rsqrt) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewZeros) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Expm1) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(ViewAs) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Narrow) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Abs) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argsort) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sub) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Exp_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Greater) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(IndexAdd) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tanh) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedFill) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalAnd) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Allclose) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log10) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Less) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Any) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Div) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isinf) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewEmpty) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Put_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log1p) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Topk) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Prod) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Transpose) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalXor) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Frac) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Repeat) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mm) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mean) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isinf) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logaddexp2) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Atan) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedFill) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Median) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Gcd) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sub_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Expm1) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Div_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Add) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(All) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Fill_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NanToNum) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Round) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Acosh) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Std) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Inverse) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NotEqual) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedFill_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addmv) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addcdiv) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argmax) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewFull) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Histc) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Eq) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tan) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logsumexp) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Minimum) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Reshape) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Remainder) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(LessEqual) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Var) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewOnes) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Select) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cumsum) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Div) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sinc) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Triu) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedSelect) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Sigmoid) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalOr) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cos) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Gather) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Nansum) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Copy_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Matmul) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(FloorDivide_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Remainder) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(To) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Hardshrink) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Dot) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isfinite) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Outer) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(CountNonzero) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Pow) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Baddbmm) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logaddexp) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tril) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Split) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Unsqueeze) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Scatter_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(TypeAs) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Subtract) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Neg) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Erf) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log1p) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(GreaterEqual) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Hardshrink) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mean) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Topk) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log2) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Allclose) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalAnd) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Chunk) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(T) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Transpose) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Select) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Greater) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Square) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sub_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Bincount) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(TrueDivide) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sinc) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Round) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Isfinite) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Add_) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Min) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Sin) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Add) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Unbind) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Asin) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Flatten) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Logaddexp) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cumsum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sub) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Copy_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(FloorDivide) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Atan2) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Floor) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(RepeatInterleave) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argmin) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(ScatterAdd) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Asin) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tile) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sort) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Acosh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Unsqueeze) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mm) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Exp) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Outer) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(IndexAdd) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(TypeAs) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Std) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Fill_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseNot) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Take) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Put_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Narrow) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Gcd) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Maximum) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Atan2) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Log2) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Median) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(T) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Atanh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Abs) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Reciprocal) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Clamp) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(MaskedSelect) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Nansum) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Asinh) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mul_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Frac) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Gather) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalOr) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Erfc) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Cos) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Argmax) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Fmod) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseOr) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Split) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Acos) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Where) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Take) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Rsqrt) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(ModMagic) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Reciprocal) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sort) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Chunk) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseNot) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Baddbmm) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addmm) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Erfc) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Ceil) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(LogicalNot) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mul) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sqrt) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Clone) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Mul_) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(Unique) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(To) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(ViewAs) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Bincount) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Subtract) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(NewOnes) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Acos) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(GreaterEqual) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(LessEqual) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Trunc) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseOr) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Pow) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Sinh) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Kthvalue) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Xlogy) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Clamp) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Asinh) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Floor) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(ExpandAs) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Square) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Scatter) \
   DEFINE_TENSOR_METHOD_CPYWRAPPER(IndexSelect) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Max) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Tril) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(FillDiagonal_) \
-  DEFINE_TENSOR_METHOD_CPYWRAPPER(Addmm)
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(BitwiseAnd) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Exp) \
+  DEFINE_TENSOR_METHOD_CPYWRAPPER(Diag)
 
 extern PyMethodDef *TensorMethods;
-void RegStubTensorMethods();
 }  // namespace tensor
 }  // namespace mindspore
 #endif  // TENSOR_PY_GEN_H

mindspore/include/mindspore/ccsrc/pybind_api/ir/tensor_register/tensor_func_reg.h

@@ -19,7 +19,6 @@
 
 #include <memory>
 #include "mindspore/core/include/ir/tensor.h"
-#include "mindspore/core/include/ir/base_tensor.h"
 #include "pybind_api/ir/tensor_api/auto_generate/tensor_api.h"
 #include "pybind11/pybind11.h"
 #include "include/common/utils/tensor_py.h"

mindspore/include/mindspore/ccsrc/pybind_api/resource/manager.h

@@ -18,7 +18,7 @@
 #define MINDSPORE_MINDSPORE_CCSRC_PYBIND_API_RESOURCE_MANAGER_H_
 #include "include/common/visible.h"
 namespace mindspore {
-void ME_EXPORT MemoryRecycle();
-void ME_EXPORT ClearResAtexit();
+void MemoryRecycle();
+void ClearResAtexit();
 }  // namespace mindspore
 #endif  // MINDSPORE_MINDSPORE_CCSRC_PYBIND_API_RESOURCE_MANAGER_H_

mindspore/include/mindspore/ccsrc/pybind_api/storage_py.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_CCSRC_PYBIND_API_STORAGE_PY_H
+#define MINDSPORE_CCSRC_PYBIND_API_STORAGE_PY_H
+
+#include <Python.h>
+#include "pybind11/pybind11.h"
+#include "frontend/ir/storage.h"
+
+namespace mindspore {
+
+struct StoragePy {
+  PyObject_HEAD Storage cdata;
+};
+
+inline const Storage &StoragePy_Unpack(StoragePy *storage) { return storage->cdata; }
+
+inline const Storage &StoragePy_Unpack(PyObject *obj) { return StoragePy_Unpack(reinterpret_cast<StoragePy *>(obj)); }
+
+PyObject *CreateStorageObj(const Storage &storage);
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_PYBIND_API_STORAGE_PY_H

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/abs.h

@@ -29,7 +29,7 @@ class PYBOOST_API Abs : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~Abs() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/acos_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AcosExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AcosExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/acosh_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AcoshExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AcoshExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adamw.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdamW : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdamW() override = default;
 
-  virtual std::tuple<mindspore::tensor::BaseTensorPtr,mindspore::tensor::BaseTensorPtr,mindspore::tensor::BaseTensorPtr> Call(const mindspore::tensor::BaseTensorPtr &var_tensor, const mindspore::tensor::BaseTensorPtr &m_tensor, const mindspore::tensor::BaseTensorPtr &v_tensor, const mindspore::tensor::BaseTensorPtr &max_v_tensor, const mindspore::tensor::BaseTensorPtr &gradient_tensor, const mindspore::tensor::BaseTensorPtr &step_tensor, const mindspore::FP32ImmPtr &lr, const mindspore::FP32ImmPtr &beta1, const mindspore::FP32ImmPtr &beta2, const mindspore::FP32ImmPtr &decay, const mindspore::FP32ImmPtr &eps, const mindspore::BoolImmPtr &amsgrad, const mindspore::BoolImmPtr &maximize) = 0;
+  virtual std::tuple<mindspore::tensor::TensorPtr,mindspore::tensor::TensorPtr,mindspore::tensor::TensorPtr> Call(const mindspore::tensor::TensorPtr &var_tensor, const mindspore::tensor::TensorPtr &m_tensor, const mindspore::tensor::TensorPtr &v_tensor, const mindspore::tensor::TensorPtr &max_v_tensor, const mindspore::tensor::TensorPtr &gradient_tensor, const mindspore::tensor::TensorPtr &step_tensor, const mindspore::FP32ImmPtr &lr, const mindspore::FP32ImmPtr &beta1, const mindspore::FP32ImmPtr &beta2, const mindspore::FP32ImmPtr &decay, const mindspore::FP32ImmPtr &eps, const mindspore::BoolImmPtr &amsgrad, const mindspore::BoolImmPtr &maximize) = 0;
   bool output_is_tuple() const override { return true; }
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_avg_pool1d.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveAvgPool1D : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveAvgPool1D() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_avg_pool2d_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveAvgPool2DExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveAvgPool2DExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_avg_pool2d_grad_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveAvgPool2DGradExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveAvgPool2DGradExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &grad_output_tensor, const mindspore::tensor::BaseTensorPtr &x_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &grad_output_tensor, const mindspore::tensor::TensorPtr &x_tensor) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_avg_pool3d_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveAvgPool3DExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveAvgPool3DExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_avg_pool3d_grad_ext.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveAvgPool3DGradExt : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveAvgPool3DGradExt() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_grad_tensor, const mindspore::tensor::BaseTensorPtr &input_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_grad_tensor, const mindspore::tensor::TensorPtr &input_tensor) = 0;
 
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_max_pool1d.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveMaxPool1D : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveMaxPool1D() override = default;
 
-  virtual std::tuple<mindspore::tensor::BaseTensorPtr,mindspore::tensor::BaseTensorPtr> Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
+  virtual std::tuple<mindspore::tensor::TensorPtr,mindspore::tensor::TensorPtr> Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
   bool output_is_tuple() const override { return true; }
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/adaptive_max_pool2d.h

@@ -29,7 +29,7 @@ class PYBOOST_API AdaptiveMaxPool2D : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~AdaptiveMaxPool2D() override = default;
 
-  virtual std::tuple<mindspore::tensor::BaseTensorPtr,mindspore::tensor::BaseTensorPtr> Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
+  virtual std::tuple<mindspore::tensor::TensorPtr,mindspore::tensor::TensorPtr> Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::ValueTuplePtr &output_size) = 0;
   bool output_is_tuple() const override { return true; }
 
  protected:

mindspore/include/mindspore/ccsrc/pyboost/auto_generate/add.h

@@ -29,7 +29,7 @@ class PYBOOST_API Add : public pyboost::OpRunner {
       : OpRunner(std::move(primitive), device_context) {}
   ~Add() override = default;
 
-  virtual mindspore::tensor::BaseTensorPtr Call(const mindspore::tensor::BaseTensorPtr &input_tensor, const mindspore::tensor::BaseTensorPtr &other_tensor) = 0;
+  virtual mindspore::tensor::TensorPtr Call(const mindspore::tensor::TensorPtr &input_tensor, const mindspore::tensor::TensorPtr &other_tensor) = 0;
 
 
  protected: