mirror of
https://github.com/pytorch/pytorch.git
synced 2026-11-20 09:04:25 +08:00
Use default dtype for torch::tensor(floating_point_values) and torch::tensor(empty braced-init-list) when dtype is not specified (#29632)
Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/29632 This PR is BC-breaking in the following way: Previously, C++ `torch::tensor` with a floating-point literal with no suffix (e.g. `torch::tensor(1.1)`) or a (nested) braced-init-list of floating-point literals with no suffix (e.g. `torch::tensor({{1.1, 2.2}})` produces a tensor with dtype `at::kDouble`. After this PR, it produces a tensor with dtype `torch::get_default_dtype()`, matching Python `torch.tensor` behavior. Test Plan: Imported from OSS Differential Revision: D18465819 Pulled By: yf225 fbshipit-source-id: 6834fe50335c677bc3832f2a5e9cf8d1ede9f665
This commit is contained in:
committed by
Facebook Github Bot
parent
3fb9bbc99b
commit
2bcac59a30
+110
-44
@@ -9,14 +9,16 @@
|
||||
|
||||
#include <test/cpp/common/support.h>
|
||||
|
||||
template <typename T>
|
||||
bool exactly_equal(at::Tensor left, T right) {
|
||||
return left.item<T>() == right;
|
||||
}
|
||||
using namespace torch::test;
|
||||
|
||||
template <typename T>
|
||||
bool almost_equal(at::Tensor left, T right, T tolerance = 1e-4) {
|
||||
return std::abs(left.item<T>() - right) < tolerance;
|
||||
bool exactly_equal(at::Tensor left, T right) {
|
||||
return left.item<T>() == right;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool almost_equal(at::Tensor left, T right, T tolerance = 1e-4) {
|
||||
return std::abs(left.item<T>() - right) < tolerance;
|
||||
}
|
||||
|
||||
#define REQUIRE_TENSOR_OPTIONS(device_, index_, type_, layout_) \
|
||||
@@ -228,7 +230,9 @@ TEST(TensorTest, TorchTensorCtorScalarIntegralType) {
|
||||
ASSERT_EQ(tensor.item<int32_t>(), 123);
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorScalarFloatingType) {
|
||||
void test_TorchTensorCtorScalarFloatingType_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
|
||||
auto tensor = torch::tensor(123.456f);
|
||||
ASSERT_EQ(tensor.numel(), 1);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({}));
|
||||
@@ -238,16 +242,21 @@ TEST(TensorTest, TorchTensorCtorScalarFloatingType) {
|
||||
tensor = torch::tensor(123.456);
|
||||
ASSERT_EQ(tensor.numel(), 1);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({}));
|
||||
ASSERT_EQ(tensor.dtype(), at::kDouble);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_TRUE(almost_equal(tensor, 123.456));
|
||||
|
||||
tensor = torch::tensor({123.456});
|
||||
ASSERT_EQ(tensor.numel(), 1);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1}));
|
||||
ASSERT_EQ(tensor.dtype(), at::kDouble);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_TRUE(almost_equal(tensor[0], 123.456));
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorScalarFloatingType) {
|
||||
test_TorchTensorCtorScalarFloatingType_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorScalarFloatingType_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorScalarBoolType) {
|
||||
auto tensor = torch::tensor(true);
|
||||
ASSERT_EQ(tensor.numel(), 1);
|
||||
@@ -309,12 +318,40 @@ TEST(TensorTest, TorchTensorCtorSingleDimIntegralType) {
|
||||
ASSERT_TRUE(exactly_equal(tensor[2], 3));
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorSingleDimFloatingType) {
|
||||
void test_TorchTensorCtorSingleDimFloatingType_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
|
||||
auto tensor = torch::tensor({1.5, 2.25, 3.125});
|
||||
ASSERT_TRUE(tensor.is_variable());
|
||||
ASSERT_EQ(tensor.numel(), 3);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({3}));
|
||||
ASSERT_EQ(tensor.dtype(), at::kDouble);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_TRUE(almost_equal(tensor[0], 1.5));
|
||||
ASSERT_TRUE(almost_equal(tensor[1], 2.25));
|
||||
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
|
||||
|
||||
tensor = torch::tensor({1.5f, 2.25f, 3.125f});
|
||||
ASSERT_TRUE(tensor.is_variable());
|
||||
ASSERT_EQ(tensor.numel(), 3);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({3}));
|
||||
ASSERT_EQ(tensor.dtype(), at::kFloat);
|
||||
ASSERT_TRUE(almost_equal(tensor[0], 1.5f));
|
||||
ASSERT_TRUE(almost_equal(tensor[1], 2.25f));
|
||||
ASSERT_TRUE(almost_equal(tensor[2], 3.125f));
|
||||
|
||||
tensor = torch::tensor(at::ArrayRef<float>({1.5, 2.25, 3.125}));
|
||||
ASSERT_TRUE(tensor.is_variable());
|
||||
ASSERT_EQ(tensor.numel(), 3);
|
||||
ASSERT_EQ(tensor.dtype(), at::kFloat);
|
||||
ASSERT_TRUE(almost_equal(tensor[0], 1.5));
|
||||
ASSERT_TRUE(almost_equal(tensor[1], 2.25));
|
||||
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
|
||||
|
||||
tensor = torch::tensor(std::vector<float>({1.5, 2.25, 3.125}));
|
||||
ASSERT_TRUE(tensor.is_variable());
|
||||
ASSERT_EQ(tensor.numel(), 3);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({3}));
|
||||
ASSERT_EQ(tensor.dtype(), at::kFloat);
|
||||
ASSERT_TRUE(almost_equal(tensor[0], 1.5));
|
||||
ASSERT_TRUE(almost_equal(tensor[1], 2.25));
|
||||
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
|
||||
@@ -337,6 +374,11 @@ TEST(TensorTest, TorchTensorCtorSingleDimFloatingType) {
|
||||
ASSERT_TRUE(almost_equal(tensor[2], 3.125));
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorSingleDimFloatingType) {
|
||||
test_TorchTensorCtorSingleDimFloatingType_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorSingleDimFloatingType_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorSingleDimBoolType) {
|
||||
auto tensor = torch::tensor({true, false, true});
|
||||
ASSERT_TRUE(tensor.is_variable());
|
||||
@@ -409,23 +451,29 @@ TEST(TensorTest, TorchTensorCtorMultiDimIntegralType) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorMultiDimFloatingType) {
|
||||
void test_TorchTensorCtorMultiDimFloatingType_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
{
|
||||
auto tensor = torch::tensor({{1.0, 2.0}});
|
||||
ASSERT_EQ(tensor.dtype(), torch::kDouble);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 2}));
|
||||
ASSERT_TRUE(torch::allclose(tensor, torch::arange(1, 3, torch::kDouble).view(tensor.sizes())));
|
||||
ASSERT_TRUE(torch::allclose(tensor, torch::arange(1, 3, default_dtype).view(tensor.sizes())));
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{{{{{{1.0, 2.0, 3.0}}}}}, {{{{{4.0, 5.0, 6.0}}}}}, {{{{{7.0, 8.0, 9.0}}}}}}}});
|
||||
ASSERT_EQ(tensor.dtype(), torch::kDouble);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 3, 1, 1, 1, 1, 3}));
|
||||
ASSERT_TRUE(torch::allclose(tensor, torch::arange(1, 10, torch::kDouble).view(tensor.sizes())));
|
||||
ASSERT_TRUE(torch::allclose(tensor, torch::arange(1, 10, default_dtype).view(tensor.sizes())));
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorMultiDimFloatingType) {
|
||||
test_TorchTensorCtorMultiDimFloatingType_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorMultiDimFloatingType_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorMultiDimBoolType) {
|
||||
{
|
||||
auto tensor = torch::tensor({{true, false}});
|
||||
@@ -473,11 +521,11 @@ TEST(TensorTest, TorchTensorCtorMultiDimErrorChecks) {
|
||||
}
|
||||
{
|
||||
ASSERT_THROWS_WITH(torch::tensor({{{1, 2.0}, {1, 2.0}}}),
|
||||
"Expected all elements of the tensor to have the same scalar type: Long, but got element of scalar type: Double");
|
||||
"Expected all elements of the tensor to have the same scalar type: Long, but got element of scalar type: Float");
|
||||
}
|
||||
{
|
||||
ASSERT_THROWS_WITH(torch::tensor({{{true, 2.0, 3}, {true, 2.0, 3}}}),
|
||||
"Expected all elements of the tensor to have the same scalar type: Bool, but got element of scalar type: Double");
|
||||
"Expected all elements of the tensor to have the same scalar type: Bool, but got element of scalar type: Float");
|
||||
}
|
||||
{
|
||||
ASSERT_THROWS_WITH(torch::tensor({{{true}, {2}}}),
|
||||
@@ -489,83 +537,101 @@ TEST(TensorTest, TorchTensorCtorMultiDimErrorChecks) {
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorMultiDim_CUDA) {
|
||||
{
|
||||
auto tensor = torch::tensor(
|
||||
{{{{{{{{1.0, 2.0, 3.0}}}}}, {{{{{4.0, 5.0, 6.0}}}}}, {{{{{7.0, 8.0, 9.0}}}}}}}},
|
||||
torch::dtype(torch::kDouble).device(torch::kCUDA));
|
||||
ASSERT_TRUE(tensor.device().is_cuda());
|
||||
ASSERT_EQ(tensor.dtype(), torch::kDouble);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 3, 1, 1, 1, 1, 3}));
|
||||
ASSERT_TRUE(torch::allclose(
|
||||
tensor,
|
||||
torch::arange(1, 10, torch::kDouble).view(tensor.sizes()).to(torch::kCUDA)));
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
void test_TorchTensorCtorMultiDim_CUDA_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
|
||||
auto tensor = torch::tensor(
|
||||
{{{{{{{{1.0, 2.0, 3.0}}}}}, {{{{{4.0, 5.0, 6.0}}}}}, {{{{{7.0, 8.0, 9.0}}}}}}}},
|
||||
torch::dtype(default_dtype).device(torch::kCUDA));
|
||||
ASSERT_TRUE(tensor.device().is_cuda());
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 3, 1, 1, 1, 1, 3}));
|
||||
ASSERT_TRUE(torch::allclose(
|
||||
tensor,
|
||||
torch::arange(1, 10, default_dtype).view(tensor.sizes()).to(torch::kCUDA)));
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorZeroSizedDim) {
|
||||
TEST(TensorTest, TorchTensorCtorMultiDim_CUDA) {
|
||||
test_TorchTensorCtorMultiDim_CUDA_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorMultiDim_CUDA_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
void test_TorchTensorCtorZeroSizedDim_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
{
|
||||
auto tensor = torch::tensor({});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{}, {}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({2, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{}, {}}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 2, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{}}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{{{{{{}}}}}}}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 1, 1, 1, 1, 1, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{{{{{{}}}}, {{{{}}}}}}}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 1, 2, 1, 1, 1, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
{
|
||||
auto tensor = torch::tensor({{{{{{{{{{}}}}}}}}}});
|
||||
ASSERT_EQ(tensor.numel(), 0);
|
||||
ASSERT_EQ(tensor.sizes(), std::vector<int64_t>({1, 1, 1, 1, 1, 1, 1, 1, 1, 0}));
|
||||
ASSERT_EQ(tensor.dtype(), torch::kFloat);
|
||||
ASSERT_EQ(tensor.dtype(), default_dtype);
|
||||
ASSERT_FALSE(tensor.requires_grad());
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorZeroSizedDim) {
|
||||
test_TorchTensorCtorZeroSizedDim_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorZeroSizedDim_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
void test_TorchTensorCtorWithoutSpecifyingDtype_expected_dtype(c10::ScalarType default_dtype) {
|
||||
AutoDefaultDtypeMode dtype_mode(default_dtype);
|
||||
|
||||
ASSERT_EQ(torch::tensor({1., 2., 3.}).dtype(), default_dtype);
|
||||
ASSERT_EQ(torch::tensor({{1., 2., 3.}}).dtype(), default_dtype);
|
||||
ASSERT_EQ(torch::tensor({1., 2., 3.}, torch::TensorOptions()).dtype(), default_dtype);
|
||||
ASSERT_EQ(torch::tensor({{1., 2., 3.}}, torch::TensorOptions()).dtype(), default_dtype);
|
||||
}
|
||||
|
||||
TEST(TensorTest, TorchTensorCtorWithoutSpecifyingDtype) {
|
||||
ASSERT_EQ(torch::tensor({1, 2, 3}).dtype(), torch::kLong);
|
||||
ASSERT_EQ(torch::tensor({{1, 2, 3}}).dtype(), torch::kLong);
|
||||
ASSERT_EQ(torch::tensor({1., 2., 3.}).dtype(), torch::kDouble);
|
||||
ASSERT_EQ(torch::tensor({{1., 2., 3.}}).dtype(), torch::kDouble);
|
||||
|
||||
ASSERT_EQ(torch::tensor({1, 2, 3}, torch::TensorOptions()).dtype(), torch::kLong);
|
||||
ASSERT_EQ(torch::tensor({{1, 2, 3}}, torch::TensorOptions()).dtype(), torch::kLong);
|
||||
ASSERT_EQ(torch::tensor({1., 2., 3.}, torch::TensorOptions()).dtype(), torch::kDouble);
|
||||
ASSERT_EQ(torch::tensor({{1., 2., 3.}}, torch::TensorOptions()).dtype(), torch::kDouble);
|
||||
|
||||
test_TorchTensorCtorWithoutSpecifyingDtype_expected_dtype(/*default_dtype=*/torch::kFloat);
|
||||
test_TorchTensorCtorWithoutSpecifyingDtype_expected_dtype(/*default_dtype=*/torch::kDouble);
|
||||
}
|
||||
|
||||
TEST(TensorTest, Arange) {
|
||||
|
||||
Reference in New Issue
Block a user