[Cpp API Compatibility] Align some other APIs (#78837)

Author: youge325

paddle/phi/api/include/compat/ATen/ops/_values.h

@@ -34,12 +34,7 @@ inline at::Tensor Tensor::_values() const {
     return paddle::Tensor(
         std::make_shared<phi::DenseTensor>(sparse_coo_tensor->values()));
   } else {
-    auto sparse_csr_tensor =
-        std::dynamic_pointer_cast<phi::SparseCsrTensor>(tensor_.impl());
-    PD_CHECK(sparse_csr_tensor != nullptr,
-             "_values: failed to cast tensor impl to SparseCsrTensor");
-    return paddle::Tensor(
-        std::make_shared<phi::DenseTensor>(sparse_csr_tensor->values()));
+    PD_THROW("_values is not implemented for SparseCsr tensors");
   }
 }
 

paddle/phi/api/include/compat/ATen/ops/chunk.h

@@ -25,38 +25,48 @@ namespace at {
 inline std::vector<Tensor> chunk(const Tensor& self,
                                  int64_t chunks,
                                  int64_t dim = 0) {
+  if (chunks <= 0) {
+    PD_THROW("chunk expects chunks to be greater than 0, got ", chunks);
+  }
+
   std::vector<Tensor> result;
   paddle::Tensor pd_tensor = self._PD_GetInner();
-  int64_t dim_size = pd_tensor.dims().size() > 0 ? pd_tensor.dims()[dim] : 1;
 
-  // PyTorch returns exactly 'chunks' number of tensors, even if some are empty
-  // When chunks > dim_size, it returns dim_size non-empty tensors plus
-  // (chunks - dim_size) empty tensors
-  if (chunks > dim_size) {
-    // First create non-empty chunks for existing elements
-    for (int64_t i = 0; i < dim_size; ++i) {
+  int64_t rank = static_cast<int64_t>(pd_tensor.dims().size());
+  if (rank == 0) {
+    PD_THROW("chunk expects at least a 1-dimensional tensor");
+  }
+
+  int64_t original_dim = dim;
+  if (dim < 0) {
+    dim += rank;
+  }
+  if (dim < 0 || dim >= rank) {
+    PD_THROW("Dimension out of range (expected to be in range of [",
+             -rank,
+             ", ",
+             rank - 1,
+             "], but got ",
+             original_dim,
+             ")");
+  }
+
+  int64_t dim_size = pd_tensor.dims()[dim];
+
+  if (dim_size == 0) {
+    for (int64_t i = 0; i < chunks; ++i) {
       auto chunk_tensor =
-          paddle::experimental::slice(pd_tensor, {dim}, {i}, {i + 1}, {1}, {});
+          paddle::experimental::slice(pd_tensor, {dim}, {0}, {0}, {1}, {});
       result.push_back(Tensor(chunk_tensor));
     }
-    // Then add empty chunks
-    for (int64_t i = dim_size; i < chunks; ++i) {
-      // Create empty tensor with same shape except for the chunk dimension
-      std::vector<int64_t> empty_shape;
-      for (int64_t j = 0; j < pd_tensor.dims().size(); ++j) {
-        if (j == dim) {
-          empty_shape.push_back(0);
-        } else {
-          empty_shape.push_back(pd_tensor.dims()[j]);
-        }
-      }
-      auto empty_tensor = paddle::experimental::empty(
-          phi::IntArray(empty_shape), pd_tensor.dtype(), pd_tensor.place());
-      result.push_back(Tensor(empty_tensor));
-    }
     return result;
   }
 
+  // PyTorch returns at most 'dim_size' non-empty chunks when chunks > dim_size
+  if (chunks > dim_size) {
+    chunks = dim_size;
+  }
+
   int64_t chunk_size = (dim_size + chunks - 1) / chunks;
   int64_t remaining = dim_size;
 

paddle/phi/api/include/compat/ATen/ops/expand.h

@@ -39,42 +39,6 @@ inline Tensor expand(const Tensor& self,
   auto input_dims = pd_tensor.dims();
   auto input_rank = static_cast<size_t>(input_dims.size());
 
-  auto tile_and_slice_to_target =
-      [&](const paddle::Tensor& input,
-          const std::vector<int64_t>& input_shape,
-          const std::vector<int64_t>& target_shape) -> Tensor {
-    size_t rank = target_shape.size();
-    std::vector<int64_t> repeat_times(rank, 1);
-    for (size_t i = 0; i < rank; ++i) {
-      auto in_size = input_shape[i];
-      auto target_size = target_shape[i];
-
-      if (in_size == 0 || target_size == 0) {
-        repeat_times[i] = 0;
-      } else if (target_size <= in_size) {
-        repeat_times[i] = 1;
-      } else {
-        repeat_times[i] = (target_size + in_size - 1) / in_size;
-      }
-    }
-
-    paddle::Tensor tiled =
-        paddle::experimental::tile(input, phi::IntArray(repeat_times));
-
-    std::vector<int64_t> axes(rank);
-    std::vector<int64_t> starts(rank, 0);
-    std::vector<int64_t> ends(rank);
-    std::vector<int64_t> strides(rank, 1);
-    for (size_t i = 0; i < rank; ++i) {
-      axes[i] = static_cast<int64_t>(i);
-      ends[i] = target_shape[i];
-    }
-
-    paddle::Tensor sliced =
-        paddle::experimental::slice(tiled, axes, starts, ends, strides, {});
-    return Tensor(sliced);
-  };
-
   // PyTorch's expand uses right-alignment semantics:
   // - For 1D tensor expand to 2D: {3}.expand({3,4}) treats input as {3,1},
   // expands to {3,4}
@@ -86,26 +50,24 @@ inline Tensor expand(const Tensor& self,
   //   then expand: dim 0: 3 stays 3, dim 1: 1 -> 4 -> result {3, 4}
 
   if (input_rank < target_rank) {
-    // Add trailing 1s to right-align with target shape (PyTorch behavior)
-    // Input {3}, target {3, 4} -> reshape to {3, 1}
-    std::vector<int64_t> reshape_vec(input_rank, 1);
+    // Add leading 1s to right-align with target shape (PyTorch behavior)
+    // Input {1, 2}, target {2, 3, 2} -> reshape to {1, 1, 2}
+    std::vector<int64_t> reshape_vec(target_rank, 1);
     for (size_t i = 0; i < input_rank; ++i) {
-      reshape_vec[i] = input_dims[i];
-    }
-    // Add trailing 1s
-    while (reshape_vec.size() < target_rank) {
-      reshape_vec.push_back(1);
+      reshape_vec[target_rank - input_rank + i] = input_dims[i];
     }
 
     // Check if Paddle's expand can handle this right-aligned shape
     // Paddle allows: input[i] == 1 (can expand), or input[i] == target[i]
     // (match)
     bool can_use_paddle_expand = true;
+    size_t fail_dim = 0;
     for (size_t i = 0; i < target_rank; ++i) {
       bool dim_can_expand = (reshape_vec[i] == 1);
       bool dim_is_matching = (reshape_vec[i] == target_size_vec[i]);
       if (!dim_can_expand && !dim_is_matching) {
         can_use_paddle_expand = false;
+        fail_dim = i;
         break;
       }
     }
@@ -119,18 +81,23 @@ inline Tensor expand(const Tensor& self,
       return Tensor(result);
     }
 
-    // If Paddle's expand can't handle it, use tile + slice as fallback
-    paddle::Tensor reshaped =
-        paddle::experimental::reshape(pd_tensor, phi::IntArray(reshape_vec));
-    return tile_and_slice_to_target(reshaped, reshape_vec, target_size_vec);
+    PD_THROW("expand(): the expanded size of the tensor (",
+             target_size_vec[fail_dim],
+             ") must match the existing size (",
+             reshape_vec[fail_dim],
+             ") at non-singleton dimension ",
+             fail_dim,
+             ".");
   } else if (input_rank == target_rank) {
-    // Same rank - check if we can use expand directly or need tile
+    // Same rank - check if we can use expand directly
     bool can_use_paddle_expand = true;
+    size_t fail_dim = 0;
     for (size_t i = 0; i < target_rank; ++i) {
       auto in_size = input_dims[i];
       auto target_size = target_size_vec[i];
       if (in_size != 1 && in_size != target_size) {
         can_use_paddle_expand = false;
+        fail_dim = i;
         break;
       }
     }
@@ -141,33 +108,20 @@ inline Tensor expand(const Tensor& self,
       return Tensor(result);
     }
 
-    // Need tile + slice fallback
-    std::vector<int64_t> input_shape(target_rank);
-    for (size_t i = 0; i < target_rank; ++i) {
-      input_shape[i] = input_dims[i];
-    }
-    return tile_and_slice_to_target(pd_tensor, input_shape, target_size_vec);
+    PD_THROW("expand(): the expanded size of the tensor (",
+             target_size_vec[fail_dim],
+             ") must match the existing size (",
+             input_dims[fail_dim],
+             ") at non-singleton dimension ",
+             fail_dim,
+             ".");
   } else {
-    // Input has more dimensions.
-    // Keep the trailing target_rank dimensions and slice leading dimensions to
-    // 1 before reshape, so total element count remains valid.
-    paddle::Tensor squeezed = pd_tensor;
-    size_t leading_dims = input_rank - target_rank;
-    for (size_t i = 0; i < leading_dims; ++i) {
-      squeezed = paddle::experimental::slice(
-          squeezed, {static_cast<int64_t>(i)}, {0}, {1}, {1}, {});
-    }
-
-    std::vector<int64_t> new_shape(target_rank);
-    for (size_t i = 0; i < target_rank; ++i) {
-      new_shape[i] = input_dims[i + (input_rank - target_rank)];
-    }
-
-    // Reshape to target rank, then reuse the same expand implementation.
-    paddle::Tensor reshaped =
-        paddle::experimental::reshape(squeezed, phi::IntArray(new_shape));
-
-    return expand(Tensor(reshaped), size, implicit);
+    PD_THROW("expand(): the number of sizes provided (",
+             target_rank,
+             ") must be greater or equal to the number of dimensions in the "
+             "tensor (",
+             input_rank,
+             ").");
   }
 }
 

paddle/phi/api/include/compat/ATen/ops/index.h

@@ -32,7 +32,7 @@ namespace at {
 inline at::Tensor index(const at::Tensor& self,
                         ArrayRef<at::indexing::TensorIndex> indices) {
   if (indices.size() == 0) {
-    return self;
+    PD_THROW("index() cannot be called with an empty index list");
   }
 
   bool has_slice = false;

paddle/phi/api/include/compat/ATen/ops/sparse_coo_tensor.h

@@ -49,12 +49,9 @@ inline at::Tensor sparse_coo_tensor(const at::Tensor& indices,
   paddle::Tensor idx = indices._PD_GetInner();
   paddle::Tensor vals = values._PD_GetInner();
 
-  if (options.dtype_opt().has_value() &&
-      options.dtype_opt().value() != values.scalar_type()) {
-    vals = paddle::experimental::cast(
-        vals,
-        compat::_PD_AtenScalarTypeToPhiDataType(options.dtype_opt().value()));
-  }
+  // PyTorch ignores dtype mismatch between values and TensorOptions in
+  // sparse_coo_tensor; the resulting sparse tensor uses values' original dtype.
+  // Do not cast or throw here.
 
   if (options.pinned_memory()) {
     phi::Place base_place = options._PD_GetPlace();

paddle/phi/api/include/compat/ATen/ops/sparse_csr_tensor.h

@@ -36,12 +36,9 @@ inline at::Tensor sparse_csr_tensor(const at::Tensor& crow_indices,
   paddle::Tensor cols = col_indices._PD_GetInner();
   paddle::Tensor vals = values._PD_GetInner();
 
-  if (options.dtype_opt().has_value() &&
-      options.dtype_opt().value() != values.scalar_type()) {
-    vals = paddle::experimental::cast(
-        vals,
-        compat::_PD_AtenScalarTypeToPhiDataType(options.dtype_opt().value()));
-  }
+  // PyTorch ignores dtype mismatch between values and TensorOptions in
+  // sparse_csr_tensor; the resulting sparse tensor uses values' original dtype.
+  // Do not cast or throw here.
 
   if (options.pinned_memory()) {
     phi::Place base_place = options._PD_GetPlace();

paddle/phi/api/include/compat/c10/cuda/impl/cuda_cmake_macros.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// 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.
+
+#pragma once
+
+// Placeholder header to satisfy PyTorch compatibility checks.
+// Paddle does not use the same CUDA cmake macros as PyTorch,
+// but the presence of this file allows downstream code to use
+// __has_include(<c10/cuda/impl/cuda_cmake_macros.h>) for feature detection.

test/cpp/compat/ATen_chunk_test.cc

@@ -58,7 +58,8 @@ TEST(TensorChunkTest, ChunkMoreChunksThanSize) {
 
   std::vector<at::Tensor> chunks = t.chunk(5, 0);
 
-  ASSERT_EQ(chunks.size(), 5);
+  // PyTorch returns at most dim_size non-empty chunks when chunks > dim_size
+  ASSERT_EQ(chunks.size(), 2);
 }
 
 TEST(TensorChunkTest, ChunkDefaultDim) {
@@ -78,3 +79,47 @@ TEST(TensorChunkTest, ChunkIntType) {
   ASSERT_EQ(chunks.size(), 3);
   ASSERT_EQ(chunks[0].dtype(), at::kInt);
 }
+
+TEST(TensorChunkTest, ChunkZeroDim) {
+  at::Tensor t = at::zeros({0, 4}, at::kFloat);
+
+  std::vector<at::Tensor> chunks = t.chunk(2, 0);
+
+  // PyTorch returns 'chunks' number of empty tensors when dim_size == 0
+  ASSERT_EQ(chunks.size(), 2);
+  ASSERT_EQ(chunks[0].size(0), 0);
+  ASSERT_EQ(chunks[1].size(0), 0);
+}
+
+TEST(TensorChunkTest, ChunkNegativeDim) {
+  at::Tensor t = at::arange(12, at::kFloat).reshape({3, 4});
+
+  // chunk(-1) should be equivalent to chunk(rank - 1) = chunk(1)
+  std::vector<at::Tensor> chunks_neg = t.chunk(2, -1);
+  std::vector<at::Tensor> chunks_pos = t.chunk(2, 1);
+
+  ASSERT_EQ(chunks_neg.size(), chunks_pos.size());
+  for (size_t i = 0; i < chunks_neg.size(); ++i) {
+    ASSERT_EQ(chunks_neg[i].sizes(), chunks_pos[i].sizes());
+  }
+}
+
+TEST(TensorChunkTest, ChunkOutOfRangeDim) {
+  at::Tensor t = at::arange(12, at::kFloat).reshape({3, 4});
+
+  ASSERT_THROW(t.chunk(2, 2), std::exception);   // dim >= rank
+  ASSERT_THROW(t.chunk(2, -3), std::exception);  // dim < -rank
+}
+
+TEST(TensorChunkTest, ChunkZeroRankTensor) {
+  at::Tensor t = at::empty({}, at::kFloat);  // 0-dim scalar tensor
+
+  ASSERT_THROW(t.chunk(2, 0), std::exception);
+}
+
+TEST(TensorChunkTest, ChunkZeroChunks) {
+  at::Tensor t = at::arange(12, at::kFloat).reshape({3, 4});
+
+  ASSERT_THROW(t.chunk(0, 0), std::exception);
+  ASSERT_THROW(t.chunk(-1, 0), std::exception);
+}