wehub-resource-sync
2491 lines
96 KiB
Python
2491 lines
96 KiB
Python
# Copyright (c) 2024 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.
|
|
import copy
|
|
import itertools
|
|
import unittest
|
|
import warnings
|
|
|
|
import numpy as np
|
|
from op_test import get_device, get_device_place, is_custom_device
|
|
from utils import dygraph_guard, static_guard
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
from paddle import base
|
|
from paddle.base import core
|
|
from paddle.tensor.to_string import DEFAULT_PRINT_OPTIONS
|
|
from paddle.utils.dlpack import DLDeviceType
|
|
|
|
|
|
class TestEagerTensor(unittest.TestCase):
|
|
def setUp(self):
|
|
self.shape = [512, 1234]
|
|
self.dtype = np.float32
|
|
self.array = np.random.uniform(0.1, 1, self.shape).astype(self.dtype)
|
|
|
|
def test_to_tensor(self):
|
|
def check_with_place(place):
|
|
with base.dygraph.guard():
|
|
paddle.set_default_dtype("float32")
|
|
# set_default_dtype should not take effect on int
|
|
x = paddle.to_tensor(1, place=place, stop_gradient=False)
|
|
np.testing.assert_array_equal(x.numpy(), [1])
|
|
self.assertNotEqual(x.dtype, paddle.float32)
|
|
|
|
y = paddle.to_tensor(2, place=x.place)
|
|
self.assertEqual(str(x.place), str(y.place))
|
|
|
|
# set_default_dtype should not take effect on numpy
|
|
x = paddle.to_tensor(
|
|
np.array([1.2]).astype("float16"),
|
|
place=place,
|
|
stop_gradient=False,
|
|
)
|
|
np.testing.assert_array_equal(
|
|
x.numpy(), np.array([1.2], "float16")
|
|
)
|
|
self.assertEqual(x.dtype, paddle.float16)
|
|
|
|
# set_default_dtype take effect on int
|
|
x = paddle.to_tensor(1, place=place)
|
|
self.assertTrue(x.dtype, paddle.int64)
|
|
|
|
# set_default_dtype take effect on float
|
|
x = paddle.to_tensor(1.2, place=place, stop_gradient=False)
|
|
np.testing.assert_array_equal(
|
|
x.numpy(), np.array([1.2]).astype("float32")
|
|
)
|
|
self.assertEqual(x.dtype, paddle.float32)
|
|
clone_x = x.clone()
|
|
np.testing.assert_array_equal(
|
|
clone_x.numpy(), np.array([1.2]).astype("float32")
|
|
)
|
|
self.assertEqual(clone_x.dtype, paddle.float32)
|
|
y = clone_x**2
|
|
y.backward()
|
|
np.testing.assert_array_equal(
|
|
x.grad.numpy(), np.array([2.4]).astype("float32")
|
|
)
|
|
y = x.cpu()
|
|
self.assertEqual(y.place.__repr__(), "Place(cpu)")
|
|
if core.is_compiled_with_cuda():
|
|
y = x.pin_memory()
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu_pinned)")
|
|
y = x.cuda()
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(None)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(device_id=0)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(blocking=False)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(blocking=True)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(device_id=0, blocking=True)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(device_id=0, blocking=False)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(core.CUDAPlace(0))
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(paddle.device("cuda:0"))
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda("cuda:0")
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda(device=0, non_blocking=False)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
y = x.cuda("cuda:0", False)
|
|
self.assertEqual(y.place.__repr__(), "Place(gpu:0)")
|
|
# non-existing place
|
|
with self.assertRaises(ValueError):
|
|
y = x.cuda("test")
|
|
# data type error
|
|
with self.assertRaises(ValueError):
|
|
y = x.cuda(["cuda:0", "cpu"])
|
|
# arg error
|
|
with self.assertRaises(ValueError):
|
|
y = x.cuda(device="cuda:0", device_id="cuda:0")
|
|
with self.assertRaises(ValueError):
|
|
y = x.cuda(blocking=True, non_blocking=True)
|
|
# too many positional args
|
|
with self.assertRaises(ValueError):
|
|
y = x.cuda("cuda:0", False, None)
|
|
|
|
# support 'dtype' is core.VarType
|
|
x = paddle.rand((2, 2))
|
|
y = paddle.to_tensor([2, 2], dtype=x.dtype)
|
|
self.assertEqual(y.dtype, paddle.float32)
|
|
|
|
# set_default_dtype take effect on complex
|
|
x = paddle.to_tensor(1 + 2j, place=place, stop_gradient=False)
|
|
np.testing.assert_array_equal(x.numpy(), [1 + 2j])
|
|
self.assertEqual(x.dtype, paddle.complex64)
|
|
|
|
paddle.set_default_dtype("float64")
|
|
x = paddle.to_tensor(1.2, place=place, stop_gradient=False)
|
|
np.testing.assert_array_equal(x.numpy(), [1.2])
|
|
self.assertEqual(x.dtype, paddle.float64)
|
|
|
|
x = paddle.to_tensor(1 + 2j, place=place, stop_gradient=False)
|
|
np.testing.assert_array_equal(x.numpy(), [1 + 2j])
|
|
self.assertEqual(x.dtype, paddle.complex128)
|
|
|
|
x = paddle.to_tensor(
|
|
1, dtype="float32", place=place, stop_gradient=False
|
|
)
|
|
np.testing.assert_array_equal(x.numpy(), [1.0])
|
|
self.assertEqual(x.dtype, paddle.float32)
|
|
self.assertEqual(x.shape, [])
|
|
self.assertEqual(x.stop_gradient, False)
|
|
self.assertEqual(x.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
x = paddle.to_tensor(
|
|
(1, 2), dtype="float32", place=place, stop_gradient=False
|
|
)
|
|
x = paddle.to_tensor(
|
|
[1, 2], dtype="float32", place=place, stop_gradient=False
|
|
)
|
|
np.testing.assert_array_equal(x.numpy(), [1.0, 2.0])
|
|
self.assertEqual(x.dtype, paddle.float32)
|
|
self.assertIsNone(x.grad)
|
|
self.assertEqual(x.shape, [2])
|
|
self.assertEqual(x.stop_gradient, False)
|
|
self.assertEqual(x.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
x = paddle.to_tensor(
|
|
self.array,
|
|
dtype="float32",
|
|
place=place,
|
|
stop_gradient=False,
|
|
)
|
|
np.testing.assert_array_equal(x.numpy(), self.array)
|
|
self.assertEqual(x.dtype, paddle.float32)
|
|
self.assertEqual(x.shape, self.shape)
|
|
self.assertEqual(x.stop_gradient, False)
|
|
self.assertEqual(x.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
y = paddle.to_tensor(x)
|
|
y = paddle.to_tensor(y, dtype="float64", place=place)
|
|
np.testing.assert_array_equal(y.numpy(), self.array)
|
|
self.assertEqual(y.dtype, paddle.float64)
|
|
self.assertEqual(y.shape, self.shape)
|
|
self.assertEqual(y.stop_gradient, True)
|
|
self.assertEqual(y.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
z = x + y
|
|
np.testing.assert_array_equal(z.numpy(), 2 * self.array)
|
|
|
|
x = paddle.to_tensor(
|
|
[1 + 2j, 1 - 2j], dtype="complex64", place=place
|
|
)
|
|
y = paddle.to_tensor(x)
|
|
np.testing.assert_array_equal(x.numpy(), [1 + 2j, 1 - 2j])
|
|
self.assertEqual(y.dtype, paddle.complex64)
|
|
self.assertEqual(y.shape, [2])
|
|
|
|
paddle.set_default_dtype("float32")
|
|
x = paddle.randn([3, 4])
|
|
x_array = np.array(x)
|
|
self.assertEqual(x_array.shape, x.numpy().shape)
|
|
self.assertEqual(x_array.dtype, x.numpy().dtype)
|
|
np.testing.assert_array_equal(x_array, x.numpy())
|
|
|
|
x = paddle.to_tensor(1.0, place=place)
|
|
self.assertEqual(x.item(), 1.0)
|
|
self.assertTrue(isinstance(x.item(), float))
|
|
|
|
x = paddle.randn([3, 2, 2])
|
|
self.assertTrue(isinstance(x.item(5), float))
|
|
self.assertTrue(isinstance(x.item(1, 0, 1), float))
|
|
self.assertEqual(x.item(5), x.item(1, 0, 1))
|
|
np.testing.assert_array_equal(
|
|
x.item(1, 0, 1), x.numpy().item(1, 0, 1)
|
|
)
|
|
|
|
x = paddle.to_tensor([[1.111111, 2.222222, 3.333333]])
|
|
self.assertEqual(x.item(0, 2), x.item(2))
|
|
self.assertAlmostEqual(x.item(2), 3.333333)
|
|
self.assertTrue(isinstance(x.item(0, 2), float))
|
|
|
|
x = paddle.to_tensor(1.0, dtype="float64")
|
|
self.assertEqual(x.item(), 1.0)
|
|
self.assertTrue(isinstance(x.item(), float))
|
|
|
|
x = paddle.to_tensor(1.0, dtype="float16")
|
|
self.assertEqual(x.item(), 1.0)
|
|
self.assertTrue(isinstance(x.item(), float))
|
|
|
|
x = paddle.to_tensor(1, dtype="uint8")
|
|
self.assertEqual(x.item(), 1)
|
|
self.assertTrue(isinstance(x.item(), int))
|
|
|
|
x = paddle.to_tensor(1, dtype="int8")
|
|
self.assertEqual(x.item(), 1)
|
|
self.assertTrue(isinstance(x.item(), int))
|
|
|
|
x = paddle.to_tensor(1, dtype="int16")
|
|
self.assertEqual(x.item(), 1)
|
|
self.assertTrue(isinstance(x.item(), int))
|
|
|
|
x = paddle.to_tensor(1, dtype="int32")
|
|
self.assertEqual(x.item(), 1)
|
|
self.assertTrue(isinstance(x.item(), int))
|
|
|
|
x = paddle.to_tensor(1, dtype="int64")
|
|
self.assertEqual(x.item(), 1)
|
|
self.assertTrue(isinstance(x.item(), int))
|
|
|
|
x = paddle.to_tensor(True)
|
|
self.assertEqual(x.item(), True)
|
|
self.assertTrue(isinstance(x.item(), bool))
|
|
|
|
x = paddle.to_tensor(1 + 1j)
|
|
self.assertEqual(x.item(), 1 + 1j)
|
|
self.assertTrue(isinstance(x.item(), complex))
|
|
|
|
# empty tensor
|
|
x = paddle.to_tensor([])
|
|
self.assertEqual(x.shape, [0])
|
|
expected_result = np.array([], dtype="float32")
|
|
self.assertEqual(x.numpy().shape, expected_result.shape)
|
|
np.testing.assert_array_equal(x.numpy(), expected_result)
|
|
|
|
numpy_array = np.random.randn(3, 4)
|
|
# convert core.DenseTensor to paddle.Tensor
|
|
dense_tensor = paddle.base.core.DenseTensor()
|
|
place = paddle.base.framework._current_expected_place()
|
|
dense_tensor.set(numpy_array, place)
|
|
x = paddle.to_tensor(dense_tensor)
|
|
np.testing.assert_array_equal(x.numpy(), numpy_array)
|
|
self.assertEqual(x.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
self.assertEqual(str(x.place), str(place))
|
|
|
|
# convert core.DenseTensor to paddle.Tensor
|
|
x = paddle.to_tensor(numpy_array)
|
|
dlpack = x.value().get_tensor()._to_dlpack()
|
|
tensor_from_dlpack = paddle.base.core.from_dlpack(dlpack)
|
|
x = paddle.to_tensor(tensor_from_dlpack)
|
|
np.testing.assert_array_equal(x.numpy(), numpy_array)
|
|
self.assertEqual(x.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
# test dtype=bfloat16
|
|
x = paddle.to_tensor(-1e6, dtype=paddle.bfloat16)
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x == -999424.0)
|
|
self.assertTrue(x.item() == -999424.0)
|
|
self.assertTrue(isinstance(x.item(), float))
|
|
|
|
x = paddle.to_tensor([-1e6, -1e6, -1e6], dtype="bfloat16")
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x[0] == -999424.0)
|
|
self.assertTrue(x[1] == -999424.0)
|
|
self.assertTrue(x[2] == -999424.0)
|
|
|
|
x = paddle.to_tensor(
|
|
-1e6, dtype=paddle.bfloat16, stop_gradient=False
|
|
)
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x == -999424.0)
|
|
y = x * x
|
|
y.backward()
|
|
self.assertTrue(x.grad == -999424.0 * 2)
|
|
|
|
# test default_type=bfloat16
|
|
paddle.set_default_dtype("bfloat16")
|
|
x = paddle.to_tensor(-1e6)
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x == -999424.0)
|
|
self.assertTrue(x.item() == -999424.0)
|
|
self.assertTrue(isinstance(x.item(), float))
|
|
|
|
x = paddle.to_tensor([-1e6, -1e6, -1e6])
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x[0] == -999424.0)
|
|
self.assertTrue(x[1] == -999424.0)
|
|
self.assertTrue(x[2] == -999424.0)
|
|
|
|
x = paddle.to_tensor(-1e6, stop_gradient=False)
|
|
self.assertEqual(x.dtype, paddle.bfloat16)
|
|
self.assertTrue(x == -999424.0)
|
|
y = x * x
|
|
y.backward()
|
|
self.assertTrue(x.grad == -999424.0 * 2)
|
|
paddle.set_default_dtype("float32")
|
|
|
|
with self.assertRaises(ValueError):
|
|
paddle.randn([3, 2, 2]).item()
|
|
with self.assertRaises(ValueError):
|
|
paddle.randn([3, 2, 2]).item(18)
|
|
with self.assertRaises(ValueError):
|
|
paddle.randn([3, 2, 2]).item(1, 2)
|
|
with self.assertRaises(ValueError):
|
|
paddle.randn([3, 2, 2]).item(2, 1, 2)
|
|
with self.assertRaises(TypeError):
|
|
paddle.to_tensor("test")
|
|
with self.assertRaises(TypeError):
|
|
paddle.to_tensor(1, dtype="test")
|
|
with self.assertRaises(ValueError):
|
|
paddle.to_tensor([[1], [2, 3]])
|
|
with self.assertRaises(ValueError):
|
|
paddle.to_tensor([[1], [2, 3]], place="test")
|
|
with self.assertRaises(ValueError):
|
|
paddle.to_tensor([[1], [2, 3]], place=1)
|
|
|
|
check_with_place(core.CPUPlace())
|
|
check_with_place("cpu")
|
|
if core.is_compiled_with_cuda():
|
|
check_with_place(core.CUDAPinnedPlace())
|
|
check_with_place("gpu_pinned")
|
|
check_with_place(get_device_place())
|
|
check_with_place("gpu:0")
|
|
|
|
def test_to_tensor_not_change_input_stop_gradient(self):
|
|
with paddle.base.dygraph.guard(core.CPUPlace()):
|
|
a = paddle.zeros([1024])
|
|
a.stop_gradient = False
|
|
b = paddle.to_tensor(a)
|
|
self.assertEqual(a.stop_gradient, False)
|
|
self.assertEqual(b.stop_gradient, True)
|
|
|
|
def test_to_tensor_change_place(self):
|
|
if core.is_compiled_with_cuda():
|
|
a_np = np.random.rand(1024, 1024)
|
|
with paddle.base.dygraph.guard(core.CPUPlace()):
|
|
a = paddle.to_tensor(a_np, place=paddle.CUDAPinnedPlace())
|
|
a = paddle.to_tensor(a)
|
|
self.assertEqual(a.place.__repr__(), "Place(cpu)")
|
|
|
|
with paddle.base.dygraph.guard(get_device_place()):
|
|
a = paddle.to_tensor(a_np, place=paddle.CUDAPinnedPlace())
|
|
a = paddle.to_tensor(a)
|
|
self.assertEqual(a.place.__repr__(), "Place(gpu:0)")
|
|
|
|
with paddle.base.dygraph.guard(get_device_place()):
|
|
a = paddle.to_tensor(a_np, place=paddle.CPUPlace())
|
|
a = paddle.to_tensor(a, place=paddle.CUDAPinnedPlace())
|
|
self.assertEqual(a.place.__repr__(), "Place(gpu_pinned)")
|
|
|
|
def test_to_tensor_with_densetensor(self):
|
|
if core.is_compiled_with_cuda() or is_custom_device():
|
|
a_np = np.random.rand(1024, 1024)
|
|
with paddle.base.dygraph.guard(core.CPUPlace()):
|
|
dense_tensor = core.DenseTensor()
|
|
dense_tensor.set(a_np, core.CPUPlace())
|
|
a = paddle.to_tensor(dense_tensor)
|
|
np.testing.assert_array_equal(a_np, a.numpy())
|
|
|
|
with paddle.base.dygraph.guard(get_device_place()):
|
|
dense_tensor = core.DenseTensor()
|
|
dense_tensor.set(a_np, get_device_place())
|
|
a = paddle.to_tensor(dense_tensor, place=core.CPUPlace())
|
|
np.testing.assert_array_equal(a_np, a.numpy())
|
|
self.assertTrue(a.place.__repr__(), "Place(cpu)")
|
|
|
|
def test_to_tensor_attributes(self):
|
|
var = paddle.to_tensor(self.array)
|
|
np.testing.assert_array_equal(var.numpy(), self.array)
|
|
# default value
|
|
self.assertEqual(var.persistable, False)
|
|
self.assertEqual(var.stop_gradient, True)
|
|
self.assertEqual(var.shape, self.shape)
|
|
self.assertEqual(var.dtype, paddle.float32)
|
|
self.assertEqual(var.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
def test_tensor_pin_memory_and_device(self):
|
|
if core.is_compiled_with_cuda():
|
|
tensor_res = paddle.tensor(
|
|
self.array, device=get_device(), pin_memory=True
|
|
)
|
|
self.assertEqual(tensor_res.place, core.CUDAPinnedPlace())
|
|
|
|
tensor_cuda = paddle.tensor(self.array, device="cuda:0")
|
|
self.assertEqual(tensor_cuda.place, get_device_place())
|
|
|
|
tensor_pin = paddle.tensor(self.array, device="gpu_pinned")
|
|
self.assertEqual(tensor_pin.place, core.CUDAPinnedPlace())
|
|
|
|
if core.is_compiled_with_xpu():
|
|
tensor_res = paddle.tensor(
|
|
self.array, device="xpu", pin_memory=True
|
|
)
|
|
self.assertEqual(tensor_res.place, core.XPUPinnedPlace())
|
|
|
|
tensor_pin = paddle.tensor(self.array, device="xpu_pinned")
|
|
self.assertEqual(tensor_pin.place, core.XPUPinnedPlace())
|
|
|
|
# ``device="cpu", pin_memory=True`` is relaxed to map onto the
|
|
# available pinned allocator (matching torch's pin_memory contract).
|
|
# On a pure-CPU build there is no pinned allocator at all, so the
|
|
# call must raise with the legacy "Pinning memory is not supported"
|
|
# message; on GPU/XPU builds it succeeds and produces a pinned
|
|
# tensor.
|
|
if core.is_compiled_with_xpu():
|
|
tensor_res = paddle.tensor(
|
|
self.array, device="cpu", pin_memory=True
|
|
)
|
|
self.assertEqual(tensor_res.place, core.XPUPinnedPlace())
|
|
elif core.is_compiled_with_cuda():
|
|
tensor_res = paddle.tensor(
|
|
self.array, device="cpu", pin_memory=True
|
|
)
|
|
self.assertEqual(tensor_res.place, core.CUDAPinnedPlace())
|
|
else:
|
|
with self.assertRaises(RuntimeError) as context:
|
|
paddle.tensor(
|
|
self.array,
|
|
device="cpu",
|
|
pin_memory=True,
|
|
)
|
|
self.assertIn(
|
|
"Pinning memory is not supported",
|
|
str(context.exception),
|
|
)
|
|
|
|
def test_tensor_and_to_tensor(self):
|
|
"""
|
|
test tensor equal to to_tensor
|
|
"""
|
|
tensor_res = paddle.tensor(
|
|
self.array, dtype="float32", device="cpu", requires_grad=True
|
|
)
|
|
tensor_target = paddle.to_tensor(
|
|
self.array, dtype="float32", place="cpu", stop_gradient=False
|
|
)
|
|
np.testing.assert_array_equal(tensor_res.numpy(), tensor_target.numpy())
|
|
self.assertEqual(tensor_res.place, tensor_target.place)
|
|
self.assertEqual(tensor_res.place, core.CPUPlace())
|
|
self.assertEqual(tensor_res.dtype, tensor_target.dtype)
|
|
self.assertEqual(tensor_res.dtype, paddle.float32)
|
|
self.assertEqual(tensor_res.stop_gradient, tensor_target.stop_gradient)
|
|
self.assertEqual(tensor_res.stop_gradient, False)
|
|
|
|
def test_tensor_module(self):
|
|
"""
|
|
test paddle.tensor usable as an API and a module
|
|
"""
|
|
tensor_api = paddle.tensor(self.array, dtype="float32")
|
|
tensor_module = paddle.tensor.creation.tensor(
|
|
self.array, dtype="float32"
|
|
)
|
|
np.testing.assert_array_equal(tensor_api.numpy(), tensor_module.numpy())
|
|
self.assertEqual(tensor_api.place, tensor_module.place)
|
|
self.assertEqual(tensor_api.dtype, tensor_module.dtype)
|
|
self.assertEqual(tensor_api.stop_gradient, tensor_module.stop_gradient)
|
|
|
|
def test_tensor_method_or_module(self):
|
|
"""
|
|
test the class method
|
|
"""
|
|
# __rerp__
|
|
ori_repr = repr(paddle.tensor.creation.tensor)
|
|
now_repr = repr(paddle.tensor)
|
|
self.assertEqual(ori_repr, now_repr)
|
|
|
|
# __str__
|
|
ori_str = str(paddle.tensor.creation.tensor)
|
|
now_str = str(paddle.tensor)
|
|
self.assertEqual(ori_str, now_str)
|
|
|
|
# __dir__
|
|
api_dir = dir(paddle.tensor.creation.tensor)
|
|
module_dir = dir(paddle.tensor)
|
|
self.assertGreater(len(module_dir), len(api_dir))
|
|
|
|
def test_list_to_tensor(self):
|
|
array = [[[1, 2], [1, 2], [1.0, 2]], [[1, 2], [1, 2], [1, 2]]]
|
|
var = paddle.to_tensor(array, dtype="int32")
|
|
np.testing.assert_array_equal(var.numpy(), array)
|
|
self.assertEqual(var.shape, [2, 3, 2])
|
|
self.assertEqual(var.dtype, paddle.int32)
|
|
self.assertEqual(var.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
def test_tuple_to_tensor(self):
|
|
array = (((1, 2), (1, 2), (1, 2)), ((1, 2), (1, 2), (1, 2)))
|
|
var = paddle.to_tensor(array, dtype="float32")
|
|
np.testing.assert_array_equal(var.numpy(), array)
|
|
self.assertEqual(var.shape, [2, 3, 2])
|
|
self.assertEqual(var.dtype, paddle.float32)
|
|
self.assertEqual(var.type, core.VarDesc.VarType.DENSE_TENSOR)
|
|
|
|
def test_tensor_to_tensor(self):
|
|
t = base.Tensor()
|
|
t.set(np.random.random((1024, 1024)), paddle.CPUPlace())
|
|
var = paddle.to_tensor(t)
|
|
np.testing.assert_array_equal(t, var.numpy())
|
|
|
|
def test_leaf_tensor(self):
|
|
with base.dygraph.guard():
|
|
x = paddle.to_tensor(np.random.uniform(-1, 1, size=[10, 10]))
|
|
self.assertTrue(x.is_leaf)
|
|
y = x + 1
|
|
self.assertTrue(y.is_leaf)
|
|
|
|
x = paddle.to_tensor(
|
|
np.random.uniform(-1, 1, size=[10, 10]), stop_gradient=False
|
|
)
|
|
self.assertTrue(x.is_leaf)
|
|
y = x + 1
|
|
self.assertFalse(y.is_leaf)
|
|
|
|
linear = paddle.nn.Linear(10, 10)
|
|
input = paddle.to_tensor(
|
|
np.random.uniform(-1, 1, size=[10, 10]).astype("float32"),
|
|
stop_gradient=False,
|
|
)
|
|
self.assertTrue(input.is_leaf)
|
|
|
|
out = linear(input)
|
|
self.assertTrue(linear.weight.is_leaf)
|
|
self.assertTrue(linear.bias.is_leaf)
|
|
self.assertFalse(out.is_leaf)
|
|
|
|
def test_detach(self):
|
|
with base.dygraph.guard():
|
|
x = paddle.to_tensor([1.0], dtype="float64", stop_gradient=False)
|
|
detach_x = x.detach()
|
|
self.assertTrue(detach_x.stop_gradient, True)
|
|
|
|
cmp_float = (
|
|
np.allclose if core.is_compiled_with_rocm() else np.array_equal
|
|
)
|
|
detach_x[:] = 10.0
|
|
self.assertTrue(cmp_float(x.numpy(), [10.0]))
|
|
|
|
y = x**2
|
|
y.backward()
|
|
self.assertTrue(cmp_float(x.grad.numpy(), [20.0]))
|
|
self.assertIsNone(detach_x.grad)
|
|
|
|
detach_x.stop_gradient = (
|
|
False # Set stop_gradient to be False, supported auto-grad
|
|
)
|
|
z = 3 * detach_x**2
|
|
z.backward()
|
|
self.assertTrue(cmp_float(x.grad.numpy(), [20.0]))
|
|
self.assertTrue(cmp_float(detach_x.grad.numpy(), [60.0]))
|
|
|
|
with self.assertRaises(ValueError):
|
|
detach_x[:] = 5.0
|
|
|
|
detach_x.stop_gradient = True
|
|
|
|
# Due to sharing of data with origin Tensor, There are some unsafe operations:
|
|
with self.assertRaises(RuntimeError):
|
|
y = 2**x
|
|
detach_x[:] = 5.0
|
|
y.backward()
|
|
|
|
def test_write_property(self):
|
|
with base.dygraph.guard():
|
|
var = paddle.to_tensor(self.array)
|
|
|
|
self.assertEqual(var.name, "generated_tensor_0")
|
|
var.name = "test"
|
|
self.assertEqual(var.name, "test")
|
|
|
|
self.assertEqual(var.persistable, False)
|
|
var.persistable = True
|
|
self.assertEqual(var.persistable, True)
|
|
|
|
self.assertEqual(var.stop_gradient, True)
|
|
var.stop_gradient = False
|
|
self.assertEqual(var.stop_gradient, False)
|
|
|
|
def test_deep_copy(self):
|
|
with base.dygraph.guard():
|
|
empty_var = core.eager.Tensor()
|
|
empty_var_copy = copy.deepcopy(empty_var)
|
|
self.assertEqual(
|
|
empty_var.stop_gradient, empty_var_copy.stop_gradient
|
|
)
|
|
self.assertEqual(empty_var.persistable, empty_var_copy.persistable)
|
|
self.assertEqual(empty_var.type, empty_var_copy.type)
|
|
self.assertEqual(empty_var.dtype, empty_var_copy.dtype)
|
|
|
|
x = paddle.to_tensor([2.0], stop_gradient=False)
|
|
y = paddle.to_tensor([3.0], stop_gradient=False)
|
|
z = x * y
|
|
memo = {}
|
|
x_copy = copy.deepcopy(x, memo)
|
|
y_copy = copy.deepcopy(y, memo)
|
|
|
|
self.assertEqual(x_copy.stop_gradient, y_copy.stop_gradient)
|
|
self.assertEqual(x_copy.persistable, y_copy.persistable)
|
|
self.assertEqual(x_copy.type, y_copy.type)
|
|
self.assertEqual(x_copy.dtype, y_copy.dtype)
|
|
np.testing.assert_array_equal(x.numpy(), x_copy.numpy())
|
|
np.testing.assert_array_equal(y.numpy(), y_copy.numpy())
|
|
|
|
self.assertNotEqual(id(x), id(x_copy))
|
|
np.testing.assert_array_equal(x.numpy(), [2.0])
|
|
|
|
with self.assertRaises(ValueError):
|
|
x_copy[:] = 5.0
|
|
|
|
x_copy2 = copy.deepcopy(x, memo)
|
|
y_copy2 = copy.deepcopy(y, memo)
|
|
self.assertEqual(id(x_copy), id(x_copy2))
|
|
self.assertEqual(id(y_copy), id(y_copy2))
|
|
|
|
# test copy selected rows
|
|
x = core.eager.Tensor(
|
|
core.VarDesc.VarType.FP32,
|
|
[3, 100],
|
|
"selected_rows",
|
|
core.VarDesc.VarType.SELECTED_ROWS,
|
|
True,
|
|
)
|
|
|
|
selected_rows = x.value().get_selected_rows()
|
|
selected_rows.get_tensor().set(
|
|
np.random.rand(3, 100), core.CPUPlace()
|
|
)
|
|
selected_rows.set_height(10)
|
|
selected_rows.set_rows([3, 5, 7])
|
|
x_copy = copy.deepcopy(x)
|
|
|
|
self.assertEqual(x_copy.stop_gradient, x.stop_gradient)
|
|
self.assertEqual(x_copy.persistable, x.persistable)
|
|
self.assertEqual(x_copy.type, x.type)
|
|
self.assertEqual(x_copy.dtype, x.dtype)
|
|
|
|
copy_selected_rows = x_copy.value().get_selected_rows()
|
|
self.assertEqual(
|
|
copy_selected_rows.height(), selected_rows.height()
|
|
)
|
|
self.assertEqual(copy_selected_rows.rows(), selected_rows.rows())
|
|
np.testing.assert_array_equal(
|
|
np.array(copy_selected_rows.get_tensor()),
|
|
np.array(selected_rows.get_tensor()),
|
|
)
|
|
|
|
def test_deep_copy_0size_tensor(self):
|
|
x = paddle.to_tensor(np.array([]))
|
|
x_copy = copy.deepcopy(x)
|
|
self.assertEqual(x_copy.stop_gradient, x.stop_gradient)
|
|
self.assertEqual(x_copy.persistable, x.persistable)
|
|
self.assertEqual(x_copy.type, x.type)
|
|
self.assertEqual(x_copy.dtype, x.dtype)
|
|
self.assertEqual(x_copy.shape, x.shape)
|
|
self.assertEqual(str(x_copy.place), str(x.place))
|
|
np.testing.assert_array_equal(x.numpy(), x_copy.numpy())
|
|
|
|
# test some patched methods
|
|
def test_set_value(self):
|
|
var = paddle.to_tensor(self.array)
|
|
tmp1 = np.random.uniform(0.1, 1, [2, 2, 3]).astype(self.dtype)
|
|
self.assertRaises(AssertionError, var.set_value, tmp1)
|
|
|
|
tmp2 = np.random.uniform(0.1, 1, self.shape).astype(self.dtype)
|
|
var.set_value(tmp2)
|
|
np.testing.assert_array_equal(var.numpy(), tmp2)
|
|
|
|
def test_to_string(self):
|
|
var = paddle.to_tensor(self.array)
|
|
self.assertTrue(isinstance(str(var), str))
|
|
|
|
def test_element_size(self):
|
|
with base.dygraph.guard():
|
|
x = paddle.to_tensor(1, dtype="bool")
|
|
self.assertEqual(x.element_size(), 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="float16")
|
|
self.assertEqual(x.element_size(), 2)
|
|
|
|
x = paddle.to_tensor(1, dtype="float32")
|
|
self.assertEqual(x.element_size(), 4)
|
|
|
|
x = paddle.to_tensor(1, dtype="float64")
|
|
self.assertEqual(x.element_size(), 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="int8")
|
|
self.assertEqual(x.element_size(), 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="int16")
|
|
self.assertEqual(x.element_size(), 2)
|
|
|
|
x = paddle.to_tensor(1, dtype="int32")
|
|
self.assertEqual(x.element_size(), 4)
|
|
|
|
x = paddle.to_tensor(1, dtype="int64")
|
|
self.assertEqual(x.element_size(), 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="uint8")
|
|
self.assertEqual(x.element_size(), 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="complex64")
|
|
self.assertEqual(x.element_size(), 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="complex128")
|
|
self.assertEqual(x.element_size(), 16)
|
|
|
|
def test_itemsize(self):
|
|
with base.dygraph.guard():
|
|
x = paddle.to_tensor(1, dtype="bool")
|
|
self.assertEqual(x.itemsize, 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="float16")
|
|
self.assertEqual(x.itemsize, 2)
|
|
|
|
x = paddle.to_tensor(1, dtype="float32")
|
|
self.assertEqual(x.itemsize, 4)
|
|
|
|
x = paddle.to_tensor(1, dtype="float64")
|
|
self.assertEqual(x.itemsize, 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="int8")
|
|
self.assertEqual(x.itemsize, 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="int16")
|
|
self.assertEqual(x.itemsize, 2)
|
|
|
|
x = paddle.to_tensor(1, dtype="int32")
|
|
self.assertEqual(x.itemsize, 4)
|
|
|
|
x = paddle.to_tensor(1, dtype="int64")
|
|
self.assertEqual(x.itemsize, 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="uint8")
|
|
self.assertEqual(x.itemsize, 1)
|
|
|
|
x = paddle.to_tensor(1, dtype="complex64")
|
|
self.assertEqual(x.itemsize, 8)
|
|
|
|
x = paddle.to_tensor(1, dtype="complex128")
|
|
self.assertEqual(x.itemsize, 16)
|
|
|
|
def test_backward(self):
|
|
var = paddle.to_tensor(self.array)
|
|
var.stop_gradient = False
|
|
loss = F.relu(var)
|
|
loss.backward()
|
|
grad_var = var._grad_ivar()
|
|
self.assertEqual(grad_var.shape, self.shape)
|
|
|
|
def test_gradient(self):
|
|
var = paddle.to_tensor(self.array)
|
|
var.stop_gradient = False
|
|
loss = F.relu(var)
|
|
loss.backward()
|
|
grad_var = var.gradient()
|
|
self.assertEqual(grad_var.shape, self.array.shape)
|
|
|
|
def _test_slice(self):
|
|
w = paddle.to_tensor(
|
|
np.random.random((784, 100, 100)).astype("float64")
|
|
)
|
|
|
|
for i in range(3):
|
|
nw = w[i]
|
|
self.assertEqual((100, 100), tuple(nw.shape))
|
|
|
|
nw = w[:]
|
|
self.assertEqual((784, 100, 100), tuple(nw.shape))
|
|
|
|
nw = w[:, :]
|
|
self.assertEqual((784, 100, 100), tuple(nw.shape))
|
|
|
|
nw = w[:, :, -1]
|
|
self.assertEqual((784, 100), tuple(nw.shape))
|
|
|
|
nw = w[1, 1, 1]
|
|
|
|
self.assertEqual(len(nw.shape), 0)
|
|
|
|
nw = w[:, :, :-1]
|
|
self.assertEqual((784, 100, 99), tuple(nw.shape))
|
|
|
|
tensor_array = np.array(
|
|
[
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
|
|
[[19, 20, 21], [22, 23, 24], [25, 26, 27]],
|
|
]
|
|
).astype("float32")
|
|
var = paddle.to_tensor(tensor_array)
|
|
var1 = var[0, 1, 1]
|
|
var2 = var[1:]
|
|
var3 = var[0:1]
|
|
var4 = var[::-1]
|
|
var5 = var[1, 1:, 1:]
|
|
var_reshape = paddle.reshape(var, [3, -1, 3])
|
|
var6 = var_reshape[:, :, -1]
|
|
var7 = var[:, :, :-1]
|
|
var8 = var[:1, :1, :1]
|
|
var9 = var[:-1, :-1, :-1]
|
|
var10 = var[::-1, :1, :-1]
|
|
var11 = var[:-1, ::-1, -1:]
|
|
var12 = var[1:2, 2:, ::-1]
|
|
var13 = var[2:10, 2:, -2:-1]
|
|
var14 = var[1:-1, 0:2, ::-1]
|
|
var15 = var[::-1, ::-1, ::-1]
|
|
var16 = var[-4:4]
|
|
var17 = var[:, 0, 0:0]
|
|
var18 = var[:, 1:1:2]
|
|
|
|
vars = [
|
|
var,
|
|
var1,
|
|
var2,
|
|
var3,
|
|
var4,
|
|
var5,
|
|
var6,
|
|
var7,
|
|
var8,
|
|
var9,
|
|
var10,
|
|
var11,
|
|
var12,
|
|
var13,
|
|
var14,
|
|
var15,
|
|
var16,
|
|
var17,
|
|
var18,
|
|
]
|
|
local_out = [var.numpy() for var in vars]
|
|
|
|
np.testing.assert_array_equal(local_out[1], tensor_array[0, 1, 1:2])
|
|
np.testing.assert_array_equal(local_out[2], tensor_array[1:])
|
|
np.testing.assert_array_equal(local_out[3], tensor_array[0:1])
|
|
np.testing.assert_array_equal(local_out[4], tensor_array[::-1])
|
|
np.testing.assert_array_equal(local_out[5], tensor_array[1, 1:, 1:])
|
|
np.testing.assert_array_equal(
|
|
local_out[6], tensor_array.reshape((3, -1, 3))[:, :, -1]
|
|
)
|
|
np.testing.assert_array_equal(local_out[7], tensor_array[:, :, :-1])
|
|
np.testing.assert_array_equal(local_out[8], tensor_array[:1, :1, :1])
|
|
np.testing.assert_array_equal(local_out[9], tensor_array[:-1, :-1, :-1])
|
|
np.testing.assert_array_equal(
|
|
local_out[10], tensor_array[::-1, :1, :-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[11], tensor_array[:-1, ::-1, -1:]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[12], tensor_array[1:2, 2:, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[13], tensor_array[2:10, 2:, -2:-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[14], tensor_array[1:-1, 0:2, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[15], tensor_array[::-1, ::-1, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(local_out[16], tensor_array[-4:4])
|
|
np.testing.assert_array_equal(local_out[17], tensor_array[:, 0, 0:0])
|
|
np.testing.assert_array_equal(local_out[18], tensor_array[:, 1:1:2])
|
|
|
|
def _test_slice_for_tensor_attr(self):
|
|
tensor_array = np.array(
|
|
[
|
|
[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
|
|
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
|
|
[[19, 20, 21], [22, 23, 24], [25, 26, 27]],
|
|
]
|
|
).astype("float32")
|
|
|
|
var = paddle.to_tensor(tensor_array)
|
|
|
|
one = paddle.ones(shape=[], dtype="int32")
|
|
two = paddle.full(shape=[], fill_value=2, dtype="int32")
|
|
negative_one = paddle.full(shape=[], fill_value=-1, dtype="int32")
|
|
four = paddle.full(shape=[], fill_value=4, dtype="int32")
|
|
|
|
var = paddle.to_tensor(tensor_array)
|
|
var1 = var[0, one, one]
|
|
var2 = var[one:]
|
|
var3 = var[0:one]
|
|
var4 = var[::negative_one]
|
|
var5 = var[one, one:, one:]
|
|
var_reshape = paddle.reshape(var, [3, negative_one, 3])
|
|
var6 = var_reshape[:, :, negative_one]
|
|
var7 = var[:, :, :negative_one]
|
|
var8 = var[:one, :one, :1]
|
|
var9 = var[:-1, :negative_one, :negative_one]
|
|
var10 = var[::negative_one, :one, :negative_one]
|
|
var11 = var[:negative_one, ::-1, negative_one:]
|
|
var12 = var[one:2, 2:, ::negative_one]
|
|
var13 = var[two:10, 2:, -2:negative_one]
|
|
var14 = var[1:negative_one, 0:2, ::negative_one]
|
|
var15 = var[::negative_one, ::-1, ::negative_one]
|
|
var16 = var[-4:4]
|
|
|
|
vars = [
|
|
var,
|
|
var1,
|
|
var2,
|
|
var3,
|
|
var4,
|
|
var5,
|
|
var6,
|
|
var7,
|
|
var8,
|
|
var9,
|
|
var10,
|
|
var11,
|
|
var12,
|
|
var13,
|
|
var14,
|
|
var15,
|
|
var16,
|
|
]
|
|
local_out = [var.numpy() for var in vars]
|
|
|
|
np.testing.assert_array_equal(local_out[1], tensor_array[0, 1, 1:2])
|
|
np.testing.assert_array_equal(local_out[2], tensor_array[1:])
|
|
np.testing.assert_array_equal(local_out[3], tensor_array[0:1])
|
|
np.testing.assert_array_equal(local_out[4], tensor_array[::-1])
|
|
np.testing.assert_array_equal(local_out[5], tensor_array[1, 1:, 1:])
|
|
np.testing.assert_array_equal(
|
|
local_out[6], tensor_array.reshape((3, -1, 3))[:, :, -1]
|
|
)
|
|
np.testing.assert_array_equal(local_out[7], tensor_array[:, :, :-1])
|
|
np.testing.assert_array_equal(local_out[8], tensor_array[:1, :1, :1])
|
|
np.testing.assert_array_equal(local_out[9], tensor_array[:-1, :-1, :-1])
|
|
np.testing.assert_array_equal(
|
|
local_out[10], tensor_array[::-1, :1, :-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[11], tensor_array[:-1, ::-1, -1:]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[12], tensor_array[1:2, 2:, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[13], tensor_array[2:10, 2:, -2:-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[14], tensor_array[1:-1, 0:2, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
local_out[15], tensor_array[::-1, ::-1, ::-1]
|
|
)
|
|
np.testing.assert_array_equal(local_out[16], tensor_array[-4:4])
|
|
|
|
def _test_for_getitem_ellipsis_index(self):
|
|
shape = (64, 3, 5, 256)
|
|
np_fp32_value = np.random.random(shape).astype("float32")
|
|
np_int_value = np.random.randint(1, 100, shape)
|
|
|
|
var_fp32 = paddle.to_tensor(np_fp32_value)
|
|
var_int = paddle.to_tensor(np_int_value)
|
|
|
|
def assert_getitem_ellipsis_index(var_tensor, var_np):
|
|
var = [
|
|
var_tensor[..., 0].numpy(),
|
|
var_tensor[..., 1, 0].numpy(),
|
|
var_tensor[0, ..., 1, 0].numpy(),
|
|
var_tensor[1, ..., 1].numpy(),
|
|
var_tensor[2, ...].numpy(),
|
|
var_tensor[2, 0, ...].numpy(),
|
|
var_tensor[2, 0, 1, ...].numpy(),
|
|
var_tensor[...].numpy(),
|
|
var_tensor[:, ..., 100].numpy(),
|
|
]
|
|
|
|
np.testing.assert_array_equal(var[0], var_np[..., 0])
|
|
np.testing.assert_array_equal(var[1], var_np[..., 1, 0])
|
|
np.testing.assert_array_equal(var[2], var_np[0, ..., 1, 0])
|
|
np.testing.assert_array_equal(var[3], var_np[1, ..., 1])
|
|
np.testing.assert_array_equal(var[4], var_np[2, ...])
|
|
np.testing.assert_array_equal(var[5], var_np[2, 0, ...])
|
|
np.testing.assert_array_equal(var[6], var_np[2, 0, 1, ...])
|
|
np.testing.assert_array_equal(var[7], var_np[...])
|
|
np.testing.assert_array_equal(var[8], var_np[:, ..., 100])
|
|
|
|
var_fp32 = paddle.to_tensor(np_fp32_value)
|
|
var_int = paddle.to_tensor(np_int_value)
|
|
|
|
assert_getitem_ellipsis_index(var_fp32, np_fp32_value)
|
|
assert_getitem_ellipsis_index(var_int, np_int_value)
|
|
|
|
# test 1 dim tensor
|
|
var_one_dim = paddle.to_tensor([1, 2, 3, 4])
|
|
np.testing.assert_array_equal(
|
|
var_one_dim[..., 0].numpy(), np.array([1])
|
|
)
|
|
|
|
def _test_none_index(self):
|
|
shape = (8, 64, 5, 256)
|
|
np_value = np.random.random(shape).astype("float32")
|
|
var_tensor = paddle.to_tensor(np_value)
|
|
|
|
var = [
|
|
var_tensor[1, 0, None].numpy(),
|
|
var_tensor[None, ..., 1, 0].numpy(),
|
|
var_tensor[:, :, :, None].numpy(),
|
|
var_tensor[1, ..., 1, None].numpy(),
|
|
var_tensor[2, ..., None, None].numpy(),
|
|
var_tensor[None, 2, 0, ...].numpy(),
|
|
var_tensor[None, 2, None, 1].numpy(),
|
|
var_tensor[None].numpy(),
|
|
var_tensor[0, 0, None, 0, 0, None].numpy(),
|
|
var_tensor[None, None, 0, ..., None].numpy(),
|
|
var_tensor[..., None, :, None].numpy(),
|
|
var_tensor[0, 1:10:2, None, None, ...].numpy(),
|
|
]
|
|
|
|
np.testing.assert_array_equal(var[0], np_value[1, 0, None])
|
|
np.testing.assert_array_equal(var[1], np_value[None, ..., 1, 0])
|
|
np.testing.assert_array_equal(var[2], np_value[:, :, :, None])
|
|
np.testing.assert_array_equal(var[3], np_value[1, ..., 1, None])
|
|
np.testing.assert_array_equal(var[4], np_value[2, ..., None, None])
|
|
np.testing.assert_array_equal(var[5], np_value[None, 2, 0, ...])
|
|
np.testing.assert_array_equal(var[6], np_value[None, 2, None, 1])
|
|
np.testing.assert_array_equal(var[7], np_value[None])
|
|
np.testing.assert_array_equal(var[8], np_value[0, 0, None, 0, 0, None])
|
|
np.testing.assert_array_equal(
|
|
var[9], np_value[None, None, 0, ..., None]
|
|
)
|
|
np.testing.assert_array_equal(var[10], np_value[..., None, :, None])
|
|
|
|
# TODO(zyfncg) there is a bug of dimensions when slice step > 1 and
|
|
# indices has int type
|
|
# self.assertTrue(
|
|
# np.array_equal(var[11], np_value[0, 1:10:2, None, None, ...]))
|
|
|
|
def _test_bool_index(self):
|
|
shape = (4, 2, 5, 64)
|
|
np_value = np.random.random(shape).astype("float32")
|
|
var_tensor = paddle.to_tensor(np_value)
|
|
index = [
|
|
[True, True, True, True],
|
|
[True, False, True, True],
|
|
[True, False, False, True],
|
|
[False, 0, 1, True, True],
|
|
[False, False, False, False],
|
|
]
|
|
index2d = np.array(
|
|
[[True, True], [False, False], [True, False], [True, True]]
|
|
)
|
|
tensor_index = paddle.to_tensor(index2d)
|
|
var = [
|
|
var_tensor[index[0]].numpy(),
|
|
var_tensor[index[1]].numpy(),
|
|
var_tensor[index[2]].numpy(),
|
|
var_tensor[index[3]].numpy(),
|
|
var_tensor[paddle.to_tensor(index[0])].numpy(),
|
|
var_tensor[tensor_index].numpy(),
|
|
var_tensor[paddle.to_tensor(index[4])].numpy(),
|
|
]
|
|
np.testing.assert_array_equal(var[0], np_value[index[0]])
|
|
np.testing.assert_array_equal(var[1], np_value[index[1]])
|
|
np.testing.assert_array_equal(var[2], np_value[index[2]])
|
|
np.testing.assert_array_equal(var[3], np_value[index[3]])
|
|
np.testing.assert_array_equal(var[4], np_value[index[0]])
|
|
np.testing.assert_array_equal(var[5], np_value[index2d])
|
|
np.testing.assert_array_equal(var[6], np_value[index[4]])
|
|
np.testing.assert_array_equal(
|
|
var_tensor[var_tensor > 0.67], np_value[np_value > 0.67]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
var_tensor[var_tensor < 0.55], np_value[np_value < 0.55]
|
|
)
|
|
|
|
with self.assertRaises(IndexError):
|
|
var_tensor[[True, False]]
|
|
with self.assertRaises(IndexError):
|
|
var_tensor[[True, False, False, False, False]]
|
|
with self.assertRaises(IndexError):
|
|
var_tensor[paddle.to_tensor([[True, False, False, False]])]
|
|
|
|
def _test_scalar_bool_index(self):
|
|
shape = (1, 2, 5, 64)
|
|
np_value = np.random.random(shape).astype("float32")
|
|
var_tensor = paddle.to_tensor(np_value)
|
|
index = [True]
|
|
tensor_index = paddle.to_tensor(index)
|
|
var = [
|
|
var_tensor[tensor_index].numpy(),
|
|
]
|
|
np.testing.assert_array_equal(var[0], np_value[index])
|
|
|
|
def _test_for_var(self):
|
|
np_value = np.random.random((30, 100, 100)).astype("float32")
|
|
w = paddle.to_tensor(np_value)
|
|
|
|
for i, e in enumerate(w):
|
|
np.testing.assert_array_equal(e.numpy(), np_value[i])
|
|
|
|
def _test_numpy_index(self):
|
|
array = np.arange(120).reshape([4, 5, 6])
|
|
t = paddle.to_tensor(array)
|
|
np.testing.assert_array_equal(t[np.longlong(0)].numpy(), array[0])
|
|
np.testing.assert_array_equal(
|
|
t[np.longlong(0) : np.longlong(4) : np.longlong(2)].numpy(),
|
|
array[0:4:2],
|
|
)
|
|
np.testing.assert_array_equal(t[np.int64(0)].numpy(), array[0])
|
|
np.testing.assert_array_equal(
|
|
t[np.int32(1) : np.int32(4) : np.int32(2)].numpy(), array[1:4:2]
|
|
)
|
|
np.testing.assert_array_equal(
|
|
t[np.int16(0) : np.int16(4) : np.int16(2)].numpy(), array[0:4:2]
|
|
)
|
|
|
|
def _test_list_index(self):
|
|
# case1:
|
|
array = np.arange(120).reshape([6, 5, 4])
|
|
x = paddle.to_tensor(array)
|
|
py_idx = [[0, 2, 0, 1, 3], [0, 0, 1, 2, 0]]
|
|
|
|
idx = [paddle.to_tensor(py_idx[0]), paddle.to_tensor(py_idx[1])]
|
|
np.testing.assert_array_equal(x[idx].numpy(), array[np.array(py_idx)])
|
|
np.testing.assert_array_equal(
|
|
x[py_idx].numpy(), array[np.array(py_idx)]
|
|
)
|
|
# case2:
|
|
tensor_x = paddle.to_tensor(
|
|
np.zeros(12).reshape(2, 6).astype(np.float32)
|
|
)
|
|
tensor_y1 = paddle.zeros([1], dtype="int32") + 2
|
|
tensor_y2 = paddle.zeros([1], dtype="int32") + 5
|
|
tensor_x[:, tensor_y1:tensor_y2] = 42
|
|
res = tensor_x.numpy()
|
|
exp = np.array(
|
|
[
|
|
[0.0, 0.0, 42.0, 42.0, 42.0, 0.0],
|
|
[0.0, 0.0, 42.0, 42.0, 42.0, 0.0],
|
|
]
|
|
)
|
|
np.testing.assert_array_equal(res, exp)
|
|
|
|
# case3:
|
|
row = np.array([0, 1, 2])
|
|
col = np.array([2, 1, 3])
|
|
np.testing.assert_array_equal(array[row, col], x[row, col].numpy())
|
|
|
|
def test_slice(self):
|
|
with base.dygraph.guard():
|
|
self._test_slice()
|
|
self._test_slice_for_tensor_attr()
|
|
self._test_for_var()
|
|
self._test_for_getitem_ellipsis_index()
|
|
self._test_none_index()
|
|
self._test_bool_index()
|
|
self._test_scalar_bool_index()
|
|
self._test_numpy_index()
|
|
self._test_list_index()
|
|
|
|
var = paddle.to_tensor(self.array)
|
|
np.testing.assert_array_equal(var[1, :].numpy(), self.array[1, :])
|
|
np.testing.assert_array_equal(var[::-1].numpy(), self.array[::-1])
|
|
|
|
with self.assertRaises(IndexError):
|
|
y = var[self.shape[0]]
|
|
|
|
with self.assertRaises(IndexError):
|
|
y = var[0 - self.shape[0] - 1]
|
|
|
|
with self.assertRaises(IndexError):
|
|
mask = np.array([1, 0, 1, 0], dtype=bool)
|
|
var[paddle.to_tensor([0, 1]), mask]
|
|
|
|
def test_tensor_to_np(self):
|
|
with base.dygraph.guard():
|
|
var = paddle.to_tensor(self.array)
|
|
np.testing.assert_array_equal(var.numpy(), var.numpy(False))
|
|
np.testing.assert_array_equal(
|
|
var.numpy(force=True), var.numpy(force=False)
|
|
)
|
|
|
|
def test_tensor_as_np(self):
|
|
with base.dygraph.guard():
|
|
var = paddle.to_tensor(self.array)
|
|
np.testing.assert_array_equal(var.numpy(), np.array(var))
|
|
np.testing.assert_array_equal(
|
|
var.numpy(), np.array(var, dtype=np.float32)
|
|
)
|
|
|
|
def test_if(self):
|
|
with base.dygraph.guard():
|
|
var1 = paddle.to_tensor(np.array([[[0]]]))
|
|
var2 = paddle.to_tensor(np.array([[[1]]]))
|
|
|
|
var1_bool = False
|
|
var2_bool = False
|
|
|
|
if var1:
|
|
var1_bool = True
|
|
|
|
if var2:
|
|
var2_bool = True
|
|
|
|
assert not var1_bool, "if var1 should be false"
|
|
assert var2_bool, "if var2 should be true"
|
|
assert not bool(var1), "bool(var1) is False"
|
|
assert bool(var2), "bool(var2) is True"
|
|
|
|
def test_tensor_str(self):
|
|
paddle.enable_static()
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
paddle.seed(10)
|
|
a = paddle.rand([10, 20])
|
|
paddle.set_printoptions(4, 100, 3)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[10, 20], dtype=float32, place=Place(cpu), stop_gradient=True,
|
|
[[0.2727, 0.5489, 0.8655, ..., 0.2916, 0.8525, 0.9000],
|
|
[0.3806, 0.8996, 0.0928, ..., 0.9535, 0.8378, 0.6409],
|
|
[0.1484, 0.4038, 0.8294, ..., 0.0148, 0.6520, 0.4250],
|
|
...,
|
|
[0.3426, 0.1909, 0.7240, ..., 0.4218, 0.2676, 0.5679],
|
|
[0.5561, 0.2081, 0.0676, ..., 0.9778, 0.3302, 0.9559],
|
|
[0.2665, 0.8483, 0.5389, ..., 0.4956, 0.6862, 0.9178]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str2(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor([[1.5111111, 1.0], [0, 0]])
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True,
|
|
[[1.5111, 1. ],
|
|
[0. , 0. ]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str3(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor([[-1.5111111, 1.0], [0, -0.5]])
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True,
|
|
[[-1.5111, 1. ],
|
|
[ 0. , -0.5000]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_scaler(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor(np.array(False))
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[], dtype=bool, place=Place(cpu), stop_gradient=True,
|
|
False)"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_shape_with_zero(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
x = paddle.ones((10, 10))
|
|
y = paddle.nonzero(x == 0)
|
|
a_str = str(y)
|
|
|
|
expected = """Tensor(shape=[0, 2], dtype=int64, place=Place(cpu), stop_gradient=True,
|
|
[])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_linewidth(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
paddle.seed(2021)
|
|
x = paddle.rand([128])
|
|
paddle.set_printoptions(
|
|
precision=4, threshold=1000, edgeitems=3, linewidth=80
|
|
)
|
|
a_str = str(x)
|
|
|
|
expected = """Tensor(shape=[128], dtype=float32, place=Place(cpu), stop_gradient=True,
|
|
[0.3759, 0.0278, 0.2489, 0.3110, 0.9105, 0.7381, 0.1905, 0.4726, 0.2435,
|
|
0.9142, 0.3367, 0.7243, 0.7664, 0.9915, 0.2921, 0.1363, 0.8096, 0.2915,
|
|
0.9564, 0.9972, 0.2573, 0.2597, 0.3429, 0.2484, 0.9579, 0.7003, 0.4126,
|
|
0.4274, 0.0074, 0.9686, 0.9910, 0.0144, 0.6564, 0.2932, 0.7114, 0.9301,
|
|
0.6421, 0.0538, 0.1273, 0.5771, 0.9336, 0.6416, 0.1832, 0.9311, 0.7702,
|
|
0.7474, 0.4479, 0.3382, 0.5579, 0.0444, 0.9802, 0.9874, 0.3038, 0.5640,
|
|
0.2408, 0.5489, 0.8866, 0.1006, 0.5881, 0.7560, 0.7928, 0.8604, 0.4670,
|
|
0.9285, 0.1482, 0.4541, 0.1307, 0.6221, 0.4902, 0.1147, 0.4415, 0.2987,
|
|
0.7276, 0.2077, 0.7551, 0.9652, 0.4369, 0.2282, 0.0047, 0.2934, 0.4308,
|
|
0.4190, 0.1442, 0.3650, 0.3056, 0.6535, 0.1211, 0.8721, 0.7408, 0.4220,
|
|
0.5937, 0.3123, 0.9198, 0.0275, 0.5338, 0.4622, 0.7521, 0.3609, 0.4703,
|
|
0.1736, 0.8976, 0.7616, 0.3756, 0.2416, 0.2907, 0.3246, 0.4305, 0.5717,
|
|
0.0735, 0.0361, 0.5534, 0.4399, 0.9260, 0.6525, 0.3064, 0.4573, 0.9210,
|
|
0.8269, 0.2424, 0.7494, 0.8945, 0.7098, 0.8078, 0.4707, 0.5715, 0.7232,
|
|
0.4678, 0.5047])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_linewidth2(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
paddle.seed(2021)
|
|
x = paddle.rand([128])
|
|
paddle.set_printoptions(precision=4, linewidth=160, sci_mode=True)
|
|
a_str = str(x)
|
|
|
|
expected = """Tensor(shape=[128], dtype=float32, place=Place(cpu), stop_gradient=True,
|
|
[3.7587e-01, 2.7798e-02, 2.4891e-01, 3.1097e-01, 9.1053e-01, 7.3811e-01, 1.9045e-01, 4.7258e-01, 2.4354e-01, 9.1415e-01, 3.3666e-01, 7.2428e-01,
|
|
7.6640e-01, 9.9146e-01, 2.9215e-01, 1.3625e-01, 8.0957e-01, 2.9153e-01, 9.5642e-01, 9.9718e-01, 2.5732e-01, 2.5973e-01, 3.4292e-01, 2.4841e-01,
|
|
9.5794e-01, 7.0029e-01, 4.1260e-01, 4.2737e-01, 7.3788e-03, 9.6863e-01, 9.9102e-01, 1.4416e-02, 6.5640e-01, 2.9318e-01, 7.1136e-01, 9.3008e-01,
|
|
6.4209e-01, 5.3849e-02, 1.2730e-01, 5.7712e-01, 9.3359e-01, 6.4155e-01, 1.8320e-01, 9.3110e-01, 7.7021e-01, 7.4736e-01, 4.4793e-01, 3.3817e-01,
|
|
5.5794e-01, 4.4412e-02, 9.8023e-01, 9.8735e-01, 3.0376e-01, 5.6397e-01, 2.4082e-01, 5.4893e-01, 8.8659e-01, 1.0065e-01, 5.8812e-01, 7.5600e-01,
|
|
7.9280e-01, 8.6041e-01, 4.6701e-01, 9.2852e-01, 1.4821e-01, 4.5410e-01, 1.3074e-01, 6.2210e-01, 4.9024e-01, 1.1466e-01, 4.4154e-01, 2.9868e-01,
|
|
7.2758e-01, 2.0766e-01, 7.5508e-01, 9.6522e-01, 4.3688e-01, 2.2823e-01, 4.7394e-03, 2.9342e-01, 4.3083e-01, 4.1902e-01, 1.4416e-01, 3.6500e-01,
|
|
3.0560e-01, 6.5350e-01, 1.2115e-01, 8.7206e-01, 7.4081e-01, 4.2203e-01, 5.9372e-01, 3.1230e-01, 9.1979e-01, 2.7486e-02, 5.3383e-01, 4.6224e-01,
|
|
7.5211e-01, 3.6094e-01, 4.7034e-01, 1.7355e-01, 8.9763e-01, 7.6165e-01, 3.7557e-01, 2.4157e-01, 2.9074e-01, 3.2458e-01, 4.3049e-01, 5.7171e-01,
|
|
7.3509e-02, 3.6087e-02, 5.5341e-01, 4.3993e-01, 9.2601e-01, 6.5248e-01, 3.0640e-01, 4.5727e-01, 9.2104e-01, 8.2688e-01, 2.4243e-01, 7.4937e-01,
|
|
8.9448e-01, 7.0981e-01, 8.0783e-01, 4.7065e-01, 5.7154e-01, 7.2319e-01, 4.6777e-01, 5.0465e-01])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_bf16(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor([[1.5, 1.0], [0, 0]])
|
|
a = paddle.cast(a, dtype=paddle.bfloat16)
|
|
paddle.set_printoptions(precision=4)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=bfloat16, place=Place(cpu), stop_gradient=True,
|
|
[[1.5000, 1. ],
|
|
[0. , 0. ]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_fp8_e4m3fn(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor([[1.5, 1.0], [0, 0]])
|
|
a = paddle.cast(a, dtype=paddle.float8_e4m3fn)
|
|
paddle.set_printoptions(precision=4)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=float8_e4m3fn, place=Place(cpu), stop_gradient=True,
|
|
[[1.5000, 1. ],
|
|
[0. , 0. ]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_fp8_e5m2(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor([[1.5, 1.0], [0, 0]])
|
|
a = paddle.cast(a, dtype=paddle.float8_e5m2)
|
|
paddle.set_printoptions(precision=4)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=float8_e5m2, place=Place(cpu), stop_gradient=True,
|
|
[[1.5000, 1. ],
|
|
[0. , 0. ]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_str_complex64(self):
|
|
original_opt = copy.deepcopy(DEFAULT_PRINT_OPTIONS)
|
|
try:
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor(
|
|
[[1.5 + 1j, 1.0 - 2j], [0 - 3j, 0]], dtype="complex64"
|
|
).cpu()
|
|
paddle.set_printoptions(precision=4)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True,
|
|
[[(1.5000+1.0000j), (1.0000-2.0000j)],
|
|
[(0.0000-3.0000j), (0.0000+0.0000j)]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
paddle.set_printoptions(precision=4, sci_mode=True)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True,
|
|
[[(1.5000e+00+1.0000e+00j), (1.0000e+00-2.0000e+00j)],
|
|
[(0.0000e+00-3.0000e+00j), (0.0000e+00+0.0000e+00j)]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
finally:
|
|
paddle.set_printoptions(
|
|
precision=original_opt.precision,
|
|
threshold=original_opt.threshold,
|
|
edgeitems=original_opt.edgeitems,
|
|
sci_mode=original_opt.sci_mode,
|
|
linewidth=original_opt.linewidth,
|
|
)
|
|
|
|
def test_tensor_str_complex128(self):
|
|
original_opt = copy.deepcopy(DEFAULT_PRINT_OPTIONS)
|
|
try:
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.to_tensor(
|
|
[[1.5 + 1j, 1.0 - 2j], [0 - 3j, 0]], dtype="complex128"
|
|
).cpu()
|
|
paddle.set_printoptions(precision=4)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=complex128, place=Place(cpu), stop_gradient=True,
|
|
[[(1.5000+1.0000j), (1.0000-2.0000j)],
|
|
[(0.0000-3.0000j), (0.0000+0.0000j)]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
paddle.set_printoptions(precision=4, sci_mode=True)
|
|
a_str = str(a)
|
|
|
|
expected = """Tensor(shape=[2, 2], dtype=complex128, place=Place(cpu), stop_gradient=True,
|
|
[[(1.5000e+00+1.0000e+00j), (1.0000e+00-2.0000e+00j)],
|
|
[(0.0000e+00-3.0000e+00j), (0.0000e+00+0.0000e+00j)]])"""
|
|
|
|
self.assertEqual(a_str, expected)
|
|
finally:
|
|
paddle.set_printoptions(
|
|
precision=original_opt.precision,
|
|
threshold=original_opt.threshold,
|
|
edgeitems=original_opt.edgeitems,
|
|
sci_mode=original_opt.sci_mode,
|
|
linewidth=original_opt.linewidth,
|
|
)
|
|
|
|
def test_print_tensor_dtype(self):
|
|
paddle.disable_static(paddle.CPUPlace())
|
|
a = paddle.rand([1])
|
|
a_str = str(a.dtype)
|
|
|
|
expected = "paddle.float32"
|
|
|
|
self.assertEqual(a_str, expected)
|
|
|
|
def test_tensor_dtype_compare(self):
|
|
a = paddle.randn([2], dtype="float32")
|
|
b = paddle.randn([2], dtype="float32")
|
|
c = paddle.randn([2], dtype="float64")
|
|
|
|
self.assertTrue(a.dtype == paddle.float32)
|
|
self.assertTrue(a.dtype == b.dtype)
|
|
self.assertTrue(a.dtype != paddle.float64)
|
|
self.assertTrue(a.dtype != c.dtype)
|
|
self.assertTrue(a.dtype is paddle.float32)
|
|
self.assertTrue(a.dtype is b.dtype)
|
|
self.assertTrue(a.dtype is not paddle.float64)
|
|
self.assertTrue(a.dtype is not c.dtype)
|
|
|
|
def test_tensor_dtype_hash(self):
|
|
a = paddle.randn([2], dtype="float32")
|
|
b = paddle.randn([2], dtype="float32")
|
|
c = paddle.randn([2], dtype="float64")
|
|
|
|
self.assertEqual(hash(a.dtype), hash(paddle.float32))
|
|
self.assertEqual(hash(a.dtype), hash(b.dtype))
|
|
self.assertNotEqual(hash(a.dtype), hash(paddle.float64))
|
|
self.assertNotEqual(hash(a.dtype), hash(c.dtype))
|
|
|
|
all_types = [
|
|
paddle.complex64,
|
|
paddle.complex128,
|
|
paddle.float8_e4m3fn,
|
|
paddle.float8_e5m2,
|
|
paddle.bfloat16,
|
|
paddle.float16,
|
|
paddle.float32,
|
|
paddle.float64,
|
|
paddle.uint8,
|
|
paddle.uint16,
|
|
paddle.uint32,
|
|
paddle.uint64,
|
|
paddle.int8,
|
|
paddle.int16,
|
|
paddle.int32,
|
|
paddle.int64,
|
|
paddle.bool,
|
|
]
|
|
|
|
# Check that all dtypes have distinct hash values
|
|
self.assertEqual(len({hash(t) for t in all_types}), len(all_types))
|
|
|
|
# Verify dict lookup works with dtype as key
|
|
dtype_map = {paddle.float32: "fp32", paddle.float64: "fp64"}
|
|
self.assertEqual(dtype_map[a.dtype], "fp32")
|
|
self.assertEqual(dtype_map[c.dtype], "fp64")
|
|
|
|
@static_guard()
|
|
def test_tensor_dtype_singleton_pir(self):
|
|
"""DataType returned from PIR Value.dtype must be the same
|
|
singleton object as paddle.float32, etc."""
|
|
x = paddle.static.data('x', shape=[2], dtype='float32')
|
|
y = paddle.static.data('y', shape=[3], dtype='float64')
|
|
|
|
# Value.dtype (PIR path) should return singletons
|
|
self.assertIs(x.dtype, paddle.float32)
|
|
self.assertIs(y.dtype, paddle.float64)
|
|
|
|
# Dict lookup must work with PIR dtypes
|
|
dtype_map = {paddle.float32: "fp32", paddle.float64: "fp64"}
|
|
self.assertEqual(dtype_map[x.dtype], "fp32")
|
|
self.assertEqual(dtype_map[y.dtype], "fp64")
|
|
|
|
def test___cuda_array_interface__(self):
|
|
"""test Tensor.__cuda_array_interface__"""
|
|
with dygraph_guard():
|
|
# raise AttributeError for cpu tensor.
|
|
cpu_place = paddle.CPUPlace()
|
|
cpu_tensor = paddle.rand([3, 3]).to(device=cpu_place)
|
|
self.assertRaises(
|
|
AttributeError,
|
|
getattr,
|
|
cpu_tensor,
|
|
'__cuda_array_interface__',
|
|
)
|
|
|
|
if paddle.device.is_compiled_with_cuda():
|
|
gpu_place = get_device_place()
|
|
# raise AttributeError for sparse tensor.
|
|
sparse_tensor = (
|
|
paddle.rand([3, 3]).to(device=gpu_place).to_sparse_coo(2)
|
|
)
|
|
self.assertRaises(
|
|
AttributeError,
|
|
getattr,
|
|
sparse_tensor,
|
|
'__cuda_array_interface__',
|
|
)
|
|
|
|
# strides should be None if contiguous
|
|
tensor = paddle.randn([3, 3]).to(device=gpu_place)
|
|
interface = tensor.__cuda_array_interface__
|
|
self.assertIsNone(interface["strides"])
|
|
|
|
# strides should be tuple of int if not contiguous
|
|
tensor = paddle.randn([10, 10]).to(device=gpu_place)
|
|
tensor = tensor[::2]
|
|
interface = tensor.__cuda_array_interface__
|
|
self.assertEqual(interface["strides"], (80, 4))
|
|
|
|
# data_ptr should be 0 if tensor is 0-size
|
|
tensor = paddle.randn([0, 10]).to(device=gpu_place)
|
|
interface = tensor.__cuda_array_interface__
|
|
self.assertEqual(interface["data"][0], 0)
|
|
|
|
# raise AttributeError for tensor that requires grad.
|
|
tensor = paddle.randn([3, 3]).to(device=gpu_place)
|
|
tensor.stop_gradient = False
|
|
self.assertRaises(
|
|
RuntimeError,
|
|
getattr,
|
|
tensor,
|
|
'__cuda_array_interface__',
|
|
)
|
|
|
|
# check supports of dtypes
|
|
for dtype in [
|
|
paddle.complex64,
|
|
paddle.complex128,
|
|
paddle.bfloat16,
|
|
paddle.float16,
|
|
paddle.float32,
|
|
paddle.float64,
|
|
paddle.uint8,
|
|
paddle.int8,
|
|
paddle.int16,
|
|
paddle.int32,
|
|
paddle.int64,
|
|
paddle.bool,
|
|
]:
|
|
tensor = (
|
|
paddle.uniform([10, 10], min=-10.0, max=10.0)
|
|
.to(device=gpu_place)
|
|
.astype(dtype)
|
|
)
|
|
interface = tensor.__cuda_array_interface__
|
|
self.assertIn("typestr", interface)
|
|
self.assertIsInstance(interface["typestr"], str)
|
|
|
|
self.assertIn("shape", interface)
|
|
self.assertIsInstance(interface["shape"], tuple)
|
|
|
|
self.assertIn("strides", interface)
|
|
self.assertTrue(
|
|
isinstance(interface["strides"], tuple)
|
|
or interface["strides"] is None
|
|
)
|
|
|
|
self.assertIn("data", interface)
|
|
self.assertIsInstance(interface["data"], tuple)
|
|
self.assertEqual(len(interface["data"]), 2)
|
|
|
|
self.assertIn("version", interface)
|
|
self.assertEqual(interface["version"], 2)
|
|
|
|
def test_to_tensor_from___cuda_array_interface__(self):
|
|
# only test warning message here for cuda tensor of other framework is not supported in Paddle test, more tests code can be referenced: https://github.com/PaddlePaddle/Paddle/pull/69913
|
|
with (
|
|
dygraph_guard(),
|
|
warnings.catch_warnings(record=True) as w,
|
|
):
|
|
x = paddle.to_tensor([1, 2, 3])
|
|
paddle.to_tensor(x)
|
|
flag = paddle.tensor.creation._warned_in_tensor
|
|
self.assertTrue(flag)
|
|
|
|
def test_dlpack_device(self):
|
|
"""test Tensor.__dlpack_device__"""
|
|
with dygraph_guard():
|
|
# test CPU
|
|
tensor_cpu = paddle.to_tensor([1, 2, 3], place=base.CPUPlace())
|
|
device_type, device_id = tensor_cpu.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCPU)
|
|
self.assertEqual(device_id, None)
|
|
|
|
# test CUDA
|
|
if paddle.is_compiled_with_cuda():
|
|
tensor_cuda = paddle.to_tensor(
|
|
[1, 2, 3], place=get_device_place()
|
|
)
|
|
device_type, device_id = tensor_cuda.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCUDA)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
# test CUDA Pinned
|
|
if paddle.is_compiled_with_cuda():
|
|
tensor_pinned = paddle.to_tensor(
|
|
[1, 2, 3], place=base.CUDAPinnedPlace()
|
|
)
|
|
device_type, device_id = tensor_pinned.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCUDAHost)
|
|
self.assertEqual(device_id, None)
|
|
|
|
# test XPU
|
|
if paddle.is_compiled_with_xpu():
|
|
tensor_xpu = paddle.to_tensor([1, 2, 3], place=base.XPUPlace(0))
|
|
device_type, device_id = tensor_xpu.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLOneAPI)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
# zero_dim
|
|
# test CPU
|
|
tensor = paddle.to_tensor(5.0, place=base.CPUPlace())
|
|
device_type, device_id = tensor.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCPU)
|
|
self.assertEqual(device_id, None)
|
|
|
|
# test CUDA
|
|
if paddle.is_compiled_with_cuda():
|
|
tensor_cuda = paddle.to_tensor(5.0, place=get_device_place())
|
|
device_type, device_id = tensor_cuda.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCUDA)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
# test XPU
|
|
if paddle.is_compiled_with_xpu():
|
|
tensor_xpu = paddle.to_tensor(5.0, place=base.XPUPlace(0))
|
|
device_type, device_id = tensor_xpu.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLOneAPI)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
# zero_size
|
|
# test CPU
|
|
tensor = paddle.to_tensor(
|
|
paddle.zeros([0, 10]), place=base.CPUPlace()
|
|
)
|
|
device_type, device_id = tensor.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCPU)
|
|
self.assertEqual(device_id, None)
|
|
|
|
# test CUDA
|
|
if paddle.is_compiled_with_cuda():
|
|
tensor_cuda = paddle.to_tensor(
|
|
paddle.zeros([0, 10]), place=get_device_place()
|
|
)
|
|
device_type, device_id = tensor_cuda.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLCUDA)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
# test XPU
|
|
if paddle.is_compiled_with_xpu():
|
|
tensor_xpu = paddle.to_tensor(
|
|
paddle.zeros([0, 10]), place=base.XPUPlace(0)
|
|
)
|
|
device_type, device_id = tensor_xpu.__dlpack_device__()
|
|
self.assertEqual(device_type, DLDeviceType.kDLOneAPI)
|
|
self.assertEqual(device_id, 0)
|
|
|
|
def test_tensor__format__(self):
|
|
# test for floating point scalar
|
|
for width in range(0, 5):
|
|
paddle_scalar = paddle.randn([])
|
|
numpy_scalar = paddle_scalar.numpy()
|
|
format_spec = f".{width}f"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
format_spec = f".{width}e"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
format_spec = f".{width}g"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
|
|
format_spec = "{:.{}f}"
|
|
self.assertEqual(
|
|
format_spec.format(paddle_scalar, width),
|
|
format_spec.format(numpy_scalar, width),
|
|
)
|
|
|
|
# test for integer scalar
|
|
for width in range(0, 5):
|
|
paddle_scalar = paddle.uniform([], min=-100, max=100).to("int64")
|
|
numpy_scalar = paddle_scalar.numpy()
|
|
format_spec = f"{width}d"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
format_spec = f"{width}o"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
format_spec = f"{width}x"
|
|
self.assertEqual(
|
|
paddle_scalar.__format__(format_spec),
|
|
numpy_scalar.__format__(format_spec),
|
|
)
|
|
|
|
format_spec = "{:{}d}"
|
|
self.assertEqual(
|
|
format_spec.format(paddle_scalar, width),
|
|
format_spec.format(numpy_scalar, width),
|
|
)
|
|
|
|
# test for tensor that ndim > 0, expected to raise TypeError
|
|
paddle_scalar = paddle.uniform([1], min=-100, max=100)
|
|
self.assertRaises(TypeError, paddle_scalar.__format__, ".3f")
|
|
|
|
# test for float scalar but format_spec is 'd', expected to raise ValueError
|
|
paddle_scalar = paddle.uniform([], min=-100, max=100)
|
|
self.assertRaises(ValueError, paddle_scalar.__format__, "3d")
|
|
|
|
def test_tensor_eq_unsupported_type(self):
|
|
a = paddle.empty([2])
|
|
|
|
# Compare with None
|
|
self.assertFalse(a == None) # noqa: E711
|
|
self.assertTrue(a != None) # noqa: E711
|
|
|
|
# Compare with other obj
|
|
self.assertFalse(a == object())
|
|
self.assertTrue(a != object())
|
|
|
|
|
|
class TestEagerTensorSetitem(unittest.TestCase):
|
|
def func_setUp(self):
|
|
self.set_dtype()
|
|
self.tensor_x = paddle.to_tensor(np.ones((4, 2, 3)).astype(self.dtype))
|
|
self.np_value = np.random.random((2, 3)).astype(self.dtype)
|
|
self.tensor_value = paddle.to_tensor(self.np_value)
|
|
|
|
def set_dtype(self):
|
|
self.dtype = "int32"
|
|
|
|
def _test(self, value):
|
|
id_origin = id(self.tensor_x)
|
|
self.tensor_x[0] = value
|
|
if isinstance(value, (int, float)):
|
|
result = np.zeros((2, 3)).astype(self.dtype) + value
|
|
|
|
else:
|
|
result = self.np_value
|
|
|
|
np.testing.assert_array_equal(self.tensor_x[0].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
self.tensor_x[1:2] = value
|
|
np.testing.assert_array_equal(self.tensor_x[1].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
self.tensor_x[...] = value
|
|
np.testing.assert_array_equal(self.tensor_x[3].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
def func_test_value_tensor(self):
|
|
self._test(self.tensor_value)
|
|
|
|
def test_value_tensor(self):
|
|
self.func_setUp()
|
|
self.func_test_value_tensor()
|
|
|
|
def func_test_value_numpy(self):
|
|
self._test(self.np_value)
|
|
|
|
def test_value_numpy(self):
|
|
self.func_setUp()
|
|
self.func_test_value_numpy()
|
|
|
|
def func_test_value_int(self):
|
|
self._test(10)
|
|
|
|
def test_value_int(self):
|
|
self.func_setUp()
|
|
self.func_test_value_int()
|
|
|
|
|
|
class TestEagerTensorSetitemInt64(TestEagerTensorSetitem):
|
|
def set_dtype(self):
|
|
self.dtype = "int64"
|
|
|
|
|
|
class TestEagerTensorSetitemFp32(TestEagerTensorSetitem):
|
|
def set_dtype(self):
|
|
self.dtype = "float32"
|
|
|
|
def func_test_value_float(self):
|
|
paddle.disable_static()
|
|
self._test(3.3)
|
|
|
|
def test_value_float(self):
|
|
self.func_setUp()
|
|
self.func_test_value_float()
|
|
|
|
|
|
class TestEagerTensorSetitemFp64(TestEagerTensorSetitem):
|
|
def set_dtype(self):
|
|
self.dtype = "float64"
|
|
|
|
|
|
class TestEagerTensorSetitemBoolIndex(unittest.TestCase):
|
|
def func_setUp(self):
|
|
paddle.disable_static()
|
|
self.set_dtype()
|
|
self.set_input()
|
|
|
|
def set_input(self):
|
|
self.tensor_x = paddle.to_tensor(np.ones((4, 2, 3)).astype(self.dtype))
|
|
self.np_value = np.random.random((2, 3)).astype(self.dtype)
|
|
self.tensor_value = paddle.to_tensor(self.np_value)
|
|
|
|
def set_dtype(self):
|
|
self.dtype = "int32"
|
|
|
|
def _test(self, value):
|
|
paddle.disable_static()
|
|
|
|
id_origin = id(self.tensor_x)
|
|
index_1 = paddle.to_tensor(np.array([True, False, False, False]))
|
|
self.tensor_x[index_1] = value
|
|
|
|
if isinstance(value, (int, float)):
|
|
result = np.zeros((2, 3)).astype(self.dtype) + value
|
|
|
|
else:
|
|
result = self.np_value
|
|
|
|
np.testing.assert_array_equal(self.tensor_x[0].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
index_2 = paddle.to_tensor(np.array([False, True, False, False]))
|
|
self.tensor_x[index_2] = value
|
|
np.testing.assert_array_equal(self.tensor_x[1].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
index_3 = paddle.to_tensor(np.array([True, True, True, True]))
|
|
self.tensor_x[index_3] = value
|
|
np.testing.assert_array_equal(self.tensor_x[3].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
def func_test_value_tensor(self):
|
|
paddle.disable_static()
|
|
self._test(self.tensor_value)
|
|
|
|
def test_value_tensor(self):
|
|
self.func_setUp()
|
|
self.func_test_value_tensor()
|
|
|
|
def func_test_value_numpy(self):
|
|
paddle.disable_static()
|
|
self._test(self.np_value)
|
|
|
|
def test_value_numpy(self):
|
|
self.func_setUp()
|
|
self.func_test_value_numpy()
|
|
|
|
def func_test_value_int(self):
|
|
paddle.disable_static()
|
|
self._test(10)
|
|
|
|
def test_value_int(self):
|
|
self.func_setUp()
|
|
self.func_test_value_int()
|
|
|
|
|
|
class TestEagerTensorSetitemBoolScalarIndex(unittest.TestCase):
|
|
def set_input(self):
|
|
self.tensor_x = paddle.to_tensor(np.ones((1, 2, 3)).astype(self.dtype))
|
|
self.np_value = np.random.random((2, 3)).astype(self.dtype)
|
|
self.tensor_value = paddle.to_tensor(self.np_value)
|
|
|
|
def _test(self, value):
|
|
paddle.disable_static()
|
|
self.assertEqual(self.tensor_x.inplace_version, 0)
|
|
|
|
id_origin = id(self.tensor_x)
|
|
index = paddle.to_tensor(np.array([True]))
|
|
self.tensor_x[index] = value
|
|
self.assertEqual(self.tensor_x.inplace_version, 1)
|
|
|
|
if isinstance(value, (int, float)):
|
|
result = np.zeros((2, 3)).astype(self.dtype) + value
|
|
|
|
else:
|
|
result = self.np_value
|
|
|
|
np.testing.assert_array_equal(self.tensor_x[0].numpy(), result)
|
|
self.assertEqual(id_origin, id(self.tensor_x))
|
|
|
|
|
|
class TestEagerTensorInplaceVersion(unittest.TestCase):
|
|
def test_setitem(self):
|
|
paddle.disable_static()
|
|
|
|
var = paddle.ones(shape=[4, 2, 3], dtype="float32")
|
|
self.assertEqual(var.inplace_version, 0)
|
|
|
|
var[1] = 1
|
|
self.assertEqual(var.inplace_version, 1)
|
|
|
|
var[1:2] = 1
|
|
self.assertEqual(var.inplace_version, 2)
|
|
|
|
def test_bump_inplace_version(self):
|
|
paddle.disable_static()
|
|
var = paddle.ones(shape=[4, 2, 3], dtype="float32")
|
|
self.assertEqual(var.inplace_version, 0)
|
|
|
|
var._bump_inplace_version()
|
|
self.assertEqual(var.inplace_version, 1)
|
|
|
|
var._bump_inplace_version()
|
|
self.assertEqual(var.inplace_version, 2)
|
|
|
|
|
|
class TestEagerTensorIsCudaIsCpu(unittest.TestCase):
|
|
def test_dynamic_is_cuda_is_cpu(self):
|
|
paddle.disable_static()
|
|
cpu_tensor = paddle.to_tensor(
|
|
[2, 3], dtype="float32", place=paddle.CPUPlace()
|
|
)
|
|
self.assertFalse(cpu_tensor.is_cuda)
|
|
self.assertTrue(cpu_tensor.is_cpu)
|
|
|
|
if paddle.is_compiled_with_cuda():
|
|
gpu_tensor = paddle.to_tensor(
|
|
[2, 3], dtype="float32", place=get_device_place()
|
|
)
|
|
self.assertTrue(gpu_tensor.is_cuda)
|
|
self.assertFalse(gpu_tensor.is_cpu)
|
|
|
|
def test_static_is_cuda_is_cpu(self):
|
|
paddle.enable_static()
|
|
|
|
if paddle.is_compiled_with_cuda():
|
|
with paddle.static.program_guard(paddle.static.Program()):
|
|
data = paddle.static.data(
|
|
name='data', shape=[2], dtype='float32'
|
|
)
|
|
out = data + 1.0
|
|
|
|
gpu_exe = paddle.static.Executor(get_device_place())
|
|
gpu_result = gpu_exe.run(
|
|
feed={'data': np.array([1.0, 2.0], dtype='float32')},
|
|
fetch_list=[out],
|
|
)
|
|
self.assertTrue(data.is_cuda)
|
|
self.assertFalse(data.is_cpu)
|
|
|
|
paddle.disable_static()
|
|
|
|
|
|
class TestEagerTensorSlice(unittest.TestCase):
|
|
def test_slice(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 8))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
actual_x = x._slice(0, 1)
|
|
actual_x = paddle.to_tensor(actual_x)
|
|
self.assertEqual(actual_x.numpy().all(), np_x[0:1].all())
|
|
|
|
|
|
class TestEagerTensorClear(unittest.TestCase):
|
|
def test_clear(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 8))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
x._clear()
|
|
self.assertEqual(str(x), "Tensor(Not initialized)")
|
|
|
|
|
|
class TestEagerTensorOffset(unittest.TestCase):
|
|
def test_offset(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 8))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
expected_offset = 0
|
|
actual_x = x._slice(expected_offset, 1)
|
|
actual_x = paddle.to_tensor(actual_x)
|
|
self.assertEqual(actual_x._offset(), expected_offset)
|
|
|
|
|
|
class TestEagerTensorShareBufferTo(unittest.TestCase):
|
|
def test_share_buffer_To(self):
|
|
paddle.disable_static()
|
|
np_src = np.random.random((3, 8, 8))
|
|
src = paddle.to_tensor(np_src, dtype="float64")
|
|
# empty_var
|
|
dst = core.eager.Tensor()
|
|
src._share_buffer_to(dst)
|
|
self.assertEqual(src._is_shared_buffer_with(dst), True)
|
|
|
|
|
|
class TestEagerTensorTo(unittest.TestCase):
|
|
def func_setUp(self):
|
|
paddle.disable_static()
|
|
self.np_x = np.random.random((3, 8, 8))
|
|
self.x = paddle.to_tensor(self.np_x, dtype="float32")
|
|
|
|
def func_test_private_to_api(self):
|
|
x_double = self.x._to(dtype="double")
|
|
self.assertEqual(x_double.dtype, paddle.float64)
|
|
np.testing.assert_allclose(self.np_x, x_double, rtol=1e-05)
|
|
|
|
x_ = self.x._to()
|
|
self.assertEqual(self.x.dtype, paddle.float32)
|
|
np.testing.assert_allclose(self.np_x, x_, rtol=1e-05)
|
|
|
|
if paddle.base.is_compiled_with_cuda():
|
|
x_gpu = self.x._to(device=get_device_place())
|
|
self.assertTrue(x_gpu.place.is_gpu_place())
|
|
self.assertEqual(x_gpu.place.gpu_device_id(), 0)
|
|
|
|
x_gpu0 = self.x._to(device="gpu:0")
|
|
self.assertTrue(x_gpu0.place.is_gpu_place())
|
|
self.assertEqual(x_gpu0.place.gpu_device_id(), 0)
|
|
|
|
x_gpu1 = self.x._to(device="gpu:0", dtype="float64")
|
|
self.assertTrue(x_gpu1.place.is_gpu_place())
|
|
self.assertEqual(x_gpu1.place.gpu_device_id(), 0)
|
|
self.assertEqual(x_gpu1.dtype, paddle.float64)
|
|
|
|
x_gpu2 = self.x._to(device="gpu:0", dtype="float16")
|
|
self.assertTrue(x_gpu2.place.is_gpu_place())
|
|
self.assertEqual(x_gpu2.place.gpu_device_id(), 0)
|
|
self.assertEqual(x_gpu2.dtype, paddle.float16)
|
|
|
|
elif is_custom_device():
|
|
x_gpu = self.x._to(device=get_device_place())
|
|
self.assertTrue(x_gpu.place.is_custom_place())
|
|
self.assertEqual(x_gpu.place.custom_device_id(), 0)
|
|
|
|
x_gpu0 = self.x._to(device=get_device(True))
|
|
self.assertTrue(x_gpu0.place.is_custom_place())
|
|
self.assertEqual(x_gpu0.place.custom_device_id(), 0)
|
|
|
|
x_gpu1 = self.x._to(device=get_device(True), dtype="float64")
|
|
self.assertTrue(x_gpu1.place.is_custom_place())
|
|
self.assertEqual(x_gpu1.place.custom_device_id(), 0)
|
|
self.assertEqual(x_gpu1.dtype, paddle.float64)
|
|
|
|
x_gpu2 = self.x._to(device=get_device(True), dtype="float16")
|
|
self.assertTrue(x_gpu2.place.is_custom_place())
|
|
self.assertEqual(x_gpu2.place.custom_device_id(), 0)
|
|
self.assertEqual(x_gpu2.dtype, paddle.float16)
|
|
|
|
x_cpu = self.x._to(device=paddle.CPUPlace())
|
|
self.assertTrue(x_cpu.place.is_cpu_place())
|
|
|
|
x_cpu0 = self.x._to(device="cpu")
|
|
self.assertTrue(x_cpu0.place.is_cpu_place())
|
|
|
|
x_cpu1 = self.x._to(device=paddle.CPUPlace(), dtype="float64")
|
|
self.assertTrue(x_cpu1.place.is_cpu_place())
|
|
self.assertEqual(x_cpu1.dtype, paddle.float64)
|
|
|
|
x_cpu2 = self.x._to(device="cpu", dtype="float16")
|
|
self.assertTrue(x_cpu2.place.is_cpu_place())
|
|
self.assertEqual(x_cpu2.dtype, paddle.float16)
|
|
|
|
self.assertRaises(ValueError, self.x._to, device=1)
|
|
self.assertRaises(AssertionError, self.x._to, blocking=1)
|
|
|
|
def func_test_public_to_api(self):
|
|
# test for Tensor.to
|
|
dtypes = [
|
|
paddle.int32,
|
|
paddle.int64,
|
|
paddle.float32,
|
|
paddle.float64,
|
|
paddle.complex64,
|
|
]
|
|
places = [paddle.CPUPlace()]
|
|
if paddle.base.is_compiled_with_cuda() or is_custom_device():
|
|
places.append(get_device_place())
|
|
|
|
for src_place, src_dtype in itertools.product(places, dtypes):
|
|
src = paddle.to_tensor(
|
|
[1.0, 2.0, 3.0], dtype=src_dtype, place=src_place
|
|
)
|
|
self.assertEqual(src.dtype, src_dtype)
|
|
self.assertEqual(str(src.place), str(src_place))
|
|
src_data_ptr = src.data_ptr()
|
|
|
|
for dst_place, dst_dtype in itertools.product(places, dtypes):
|
|
dst = src.to(dtype=dst_dtype, device=dst_place)
|
|
# test for non-inplace operation
|
|
self.assertEqual(src_data_ptr, src.data_ptr())
|
|
|
|
# test for correctness of Tensor.to
|
|
self.assertEqual(dst.dtype, dst_dtype)
|
|
self.assertEqual(str(dst.place), str(dst_place))
|
|
dst_data_ptr = dst.data_ptr()
|
|
|
|
if src_place == dst_place and src_dtype == dst_dtype:
|
|
# just return self
|
|
self.assertEqual(src_data_ptr, dst_data_ptr)
|
|
self.assertEqual(src.dtype, dst.dtype)
|
|
self.assertEqual(str(src.place), str(dst.place))
|
|
elif src_place != dst_place and src_dtype == dst_dtype:
|
|
# creating new tensor from src
|
|
self.assertNotEqual(src_data_ptr, dst_data_ptr)
|
|
self.assertEqual(src.dtype, dst.dtype)
|
|
self.assertNotEqual(str(src.place), str(dst.place))
|
|
elif src_place == dst_place and src_dtype != dst_dtype:
|
|
# creating new tensor from src
|
|
self.assertNotEqual(src_data_ptr, dst_data_ptr)
|
|
self.assertNotEqual(src.dtype, dst.dtype)
|
|
self.assertEqual(str(src.place), str(dst.place))
|
|
else:
|
|
# creating new tensor from src
|
|
self.assertNotEqual(src_data_ptr, dst_data_ptr)
|
|
self.assertNotEqual(src.dtype, dst.dtype)
|
|
self.assertNotEqual(str(src.place), str(dst.place))
|
|
|
|
def test_to_api(self):
|
|
self.func_setUp()
|
|
self.func_test_private_to_api()
|
|
self.func_test_public_to_api()
|
|
|
|
|
|
class TestEagerTensorInitEagerTensorFromTensorWithDevice(unittest.TestCase):
|
|
def test_tensor_init(self):
|
|
paddle.disable_static()
|
|
t = base.Tensor()
|
|
np_x = np.random.random((3, 8, 8))
|
|
t.set(np_x, base.CPUPlace())
|
|
|
|
if paddle.base.is_compiled_with_cuda():
|
|
device = get_device_place()
|
|
tmp = base.core.eager.Tensor(t, device)
|
|
self.assertTrue(tmp.place.is_gpu_place())
|
|
self.assertEqual(tmp.numpy().all(), np_x.all())
|
|
elif is_custom_device():
|
|
device = get_device_place()
|
|
tmp = base.core.eager.Tensor(t, device)
|
|
self.assertTrue(tmp.place.is_custom_place())
|
|
self.assertEqual(tmp.numpy().all(), np_x.all())
|
|
|
|
device = paddle.CPUPlace()
|
|
tmp = base.core.eager.Tensor(t, device)
|
|
self.assertEqual(tmp.numpy().all(), np_x.all())
|
|
|
|
|
|
class TestEagerTensorNumel(unittest.TestCase):
|
|
def test_numel_normal(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 8))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
x_actual_numel = x._numel()
|
|
x_expected_numel = np.prod((3, 8, 8))
|
|
self.assertEqual(x_actual_numel, x_expected_numel)
|
|
|
|
def test_numel_without_holder(self):
|
|
paddle.disable_static()
|
|
x_without_holder = core.eager.Tensor()
|
|
x_actual_numel = x_without_holder._numel()
|
|
self.assertEqual(x_actual_numel, 0)
|
|
|
|
|
|
class TestEagerTensorNelement(unittest.TestCase):
|
|
def test_nelement(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 4))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
x_actual_nelement = x.nelement()
|
|
x_expected_nelement = np.prod((3, 8, 4))
|
|
self.assertEqual(x_actual_nelement, x_expected_nelement)
|
|
|
|
|
|
class TestEagerTensorNbytes(unittest.TestCase):
|
|
def test_nbytes(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((3, 8, 4))
|
|
x = paddle.to_tensor(np_x, dtype="float64")
|
|
x_actual_nbytes = x.nbytes
|
|
x_expected_nbytes = 3 * 8 * 4 * 8
|
|
self.assertEqual(x_actual_nbytes, x_expected_nbytes)
|
|
|
|
def test_sparse_coo_error(self):
|
|
paddle.disable_static()
|
|
indices = paddle.to_tensor([[0, 1, 2], [1, 0, 2]])
|
|
values = paddle.to_tensor([1.0, 2.0, 3.0])
|
|
shape = [3, 3]
|
|
x = paddle.sparse.sparse_coo_tensor(indices, values, shape)
|
|
with self.assertRaises(RuntimeError):
|
|
y = x.nbytes
|
|
|
|
def test_sparse_csr_error(self):
|
|
crows = paddle.to_tensor([0, 1, 2, 3])
|
|
cols = paddle.to_tensor([1, 0, 3])
|
|
values = paddle.to_tensor([5.0, 3.0, 7.0])
|
|
x = paddle.sparse.sparse_csr_tensor(crows, cols, values, [3, 4])
|
|
with self.assertRaises(RuntimeError):
|
|
y = x.nbytes
|
|
|
|
|
|
class TestEagerTensorStride(unittest.TestCase):
|
|
def test_stride_no_dim(self):
|
|
paddle.disable_static()
|
|
|
|
x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32')
|
|
stride_result = x.stride()
|
|
get_strides_result = x.get_strides()
|
|
|
|
self.assertEqual(get_strides_result, stride_result)
|
|
|
|
y = paddle.to_tensor(
|
|
[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype='float32'
|
|
)
|
|
stride_result_3d = y.stride()
|
|
get_strides_result_3d = y.get_strides()
|
|
|
|
self.assertEqual(get_strides_result_3d, stride_result_3d)
|
|
|
|
def test_stride_with_dim(self):
|
|
paddle.disable_static()
|
|
|
|
x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32')
|
|
strides = x.get_strides()
|
|
|
|
self.assertEqual(x.stride(0), strides[0])
|
|
self.assertEqual(x.stride(1), strides[1])
|
|
|
|
y = paddle.to_tensor(
|
|
[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype='float32'
|
|
)
|
|
strides_3d = y.get_strides()
|
|
|
|
self.assertEqual(y.stride(0), strides_3d[0])
|
|
self.assertEqual(y.stride(1), strides_3d[1])
|
|
self.assertEqual(y.stride(2), strides_3d[2])
|
|
|
|
def test_stride_negative_dim(self):
|
|
paddle.disable_static()
|
|
|
|
x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], dtype='float32')
|
|
strides = x.get_strides()
|
|
|
|
self.assertEqual(x.stride(-1), strides[-1])
|
|
self.assertEqual(x.stride(-2), strides[-2])
|
|
|
|
self.assertEqual(x.stride(-1), x.stride(1))
|
|
self.assertEqual(x.stride(-2), x.stride(0))
|
|
|
|
def test_stride_various_shapes(self):
|
|
paddle.disable_static()
|
|
|
|
x1d = paddle.to_tensor([1, 2, 3, 4], dtype='float32')
|
|
self.assertEqual(x1d.stride(0), x1d.get_strides()[0])
|
|
|
|
x4d = paddle.to_tensor([[[[1, 2]], [[3, 4]]]], dtype='float32')
|
|
strides_4d = x4d.get_strides()
|
|
for i in range(4):
|
|
self.assertEqual(x4d.stride(i), strides_4d[i])
|
|
|
|
def test_stride_zero_size_contiguous_view_reshape_and_slice(self):
|
|
paddle.disable_static()
|
|
|
|
x = paddle.zeros([0, 2048], dtype='float32')
|
|
self.assertEqual(x.stride(), [2048, 1])
|
|
self.assertEqual(x.get_strides(), [2048, 1])
|
|
self.assertTrue(x.is_contiguous())
|
|
|
|
viewed = x.view([0, 512, 4])
|
|
self.assertEqual(viewed.stride(), [2048, 4, 1])
|
|
self.assertEqual(viewed.get_strides(), [2048, 4, 1])
|
|
self.assertTrue(viewed.is_contiguous())
|
|
|
|
reshaped = x.reshape([0, 512, 4])
|
|
self.assertEqual(reshaped.stride(), [2048, 4, 1])
|
|
self.assertEqual(reshaped.get_strides(), [2048, 4, 1])
|
|
self.assertTrue(reshaped.is_contiguous())
|
|
|
|
sliced = x[:, ::2]
|
|
self.assertEqual(sliced.stride(), [2048, 2])
|
|
self.assertEqual(sliced.get_strides(), [2048, 2])
|
|
self.assertFalse(sliced.is_contiguous())
|
|
|
|
contiguous = sliced.contiguous()
|
|
self.assertEqual(contiguous.stride(), [1024, 1])
|
|
self.assertTrue(contiguous.is_contiguous())
|
|
|
|
def test_stride_different_dtypes(self):
|
|
paddle.disable_static()
|
|
|
|
shapes_and_dtypes = [
|
|
([[1, 2], [3, 4]], 'int32'),
|
|
([[1.0, 2.0], [3.0, 4.0]], 'float64'),
|
|
]
|
|
|
|
for data, dtype in shapes_and_dtypes:
|
|
with self.subTest(dtype=dtype):
|
|
x = paddle.to_tensor(data, dtype=dtype)
|
|
stride_result = x.stride()
|
|
get_strides_result = x.get_strides()
|
|
|
|
self.assertEqual(get_strides_result, stride_result)
|
|
|
|
def test_stride_dim_none_equiv(self):
|
|
paddle.disable_static()
|
|
x = paddle.randn([2, 3, 4])
|
|
self.assertEqual(x.stride(None), x.stride())
|
|
|
|
def test_stride_invalid_type(self):
|
|
paddle.disable_static()
|
|
x = paddle.randn([2, 3])
|
|
with self.assertRaises(ValueError):
|
|
x.stride(0.5)
|
|
with self.assertRaises(ValueError):
|
|
x.stride("0")
|
|
|
|
def test_stride_out_of_bounds(self):
|
|
paddle.disable_static()
|
|
x = paddle.randn([2, 3])
|
|
with self.assertRaises(ValueError):
|
|
x.stride(2)
|
|
with self.assertRaises(ValueError):
|
|
x.stride(-3)
|
|
|
|
|
|
class TestEagerTensorCopyGradientFrom(unittest.TestCase):
|
|
def test_copy_gradient_from(self):
|
|
paddle.disable_static()
|
|
np_x = np.random.random((2, 2))
|
|
np_y = np.random.random((2, 2))
|
|
x = paddle.to_tensor(np_x, dtype="float64", stop_gradient=False)
|
|
y = paddle.to_tensor(np_y, dtype="float64")
|
|
out = x + x
|
|
out.backward()
|
|
x._copy_gradient_from(y)
|
|
self.assertEqual(x.grad.numpy().all(), np_y.all())
|
|
|
|
|
|
class TestEagerTensorGradNameValue(unittest.TestCase):
|
|
def test_eager_tensor_grad_name_value(self):
|
|
a_np = np.array([2, 3]).astype("float32")
|
|
a = paddle.to_tensor(a_np)
|
|
a.stop_gradient = False
|
|
b = a**2
|
|
self.assertIsNone(a._grad_value())
|
|
b.backward()
|
|
# Note, for new dygraph, there are no generated grad name, so we skip the name check.
|
|
self.assertIsNotNone(a._grad_value())
|
|
|
|
|
|
class TestDenseTensorToTensor(unittest.TestCase):
|
|
def test_same_place_data_ptr_consistency(self):
|
|
places = [paddle.CPUPlace()]
|
|
if paddle.is_compiled_with_cuda() or is_custom_device():
|
|
places.append(get_device_place())
|
|
for place in places:
|
|
x = paddle.rand([3, 5]).to(device=place)
|
|
x_dense = x.get_tensor()
|
|
y = paddle.to_tensor(x_dense, place=place)
|
|
|
|
self.assertEqual(x.data_ptr(), y.data_ptr())
|
|
|
|
|
|
class TestSetDynamicAttributeToEagerTensorInstance(unittest.TestCase):
|
|
def test_set_dynamic_attribute_to_eager_tensor_instance_create_via_constructor(
|
|
self,
|
|
):
|
|
tensor_instance = paddle.to_tensor(1.0)
|
|
tensor_instance._custom_id = 0
|
|
self.assertEqual(tensor_instance._custom_id, 0)
|
|
self.assertEqual(tensor_instance.__dict__["_custom_id"], 0)
|
|
|
|
def test_set_dynamic_attribute_to_eager_tensor_instance_create_via_to_pyobject(
|
|
self,
|
|
):
|
|
original_tensor = paddle.to_tensor(-1.0)
|
|
tensor_instance = paddle.abs(original_tensor)
|
|
tensor_instance._custom_flag = True
|
|
self.assertEqual(tensor_instance._custom_flag, True)
|
|
self.assertEqual(tensor_instance.__dict__["_custom_flag"], True)
|
|
|
|
|
|
class TestListToTensor(unittest.TestCase):
|
|
def test_list_to_tensor_bfloat16(self):
|
|
a = [paddle.to_tensor(2, dtype=paddle.bfloat16)]
|
|
b = paddle.to_tensor(a)
|
|
self.assertEqual(b.dtype, paddle.bfloat16)
|
|
self.assertEqual(b[0], 2.0)
|
|
|
|
def test_list_to_tensor_float16(self):
|
|
a = [paddle.to_tensor(2, dtype=paddle.float16)]
|
|
b = paddle.to_tensor(a)
|
|
self.assertEqual(b.dtype, paddle.float16)
|
|
self.assertEqual(b[0], 2.0)
|
|
|
|
def test_list_to_tensor_bfloat16_float32(self):
|
|
a = [
|
|
paddle.to_tensor(2, dtype=paddle.bfloat16),
|
|
paddle.to_tensor(2, dtype=paddle.float32),
|
|
]
|
|
b = paddle.to_tensor(a)
|
|
self.assertEqual(b.dtype, paddle.float32)
|
|
self.assertEqual(b[0], 2.0)
|
|
self.assertEqual(b[1], 2.0)
|
|
|
|
def test_list_to_tensor_float16_float32(self):
|
|
a = [
|
|
paddle.to_tensor(2, dtype=paddle.float16),
|
|
paddle.to_tensor(2, dtype=paddle.float32),
|
|
]
|
|
b = paddle.to_tensor(a)
|
|
self.assertEqual(b.dtype, paddle.float32)
|
|
self.assertEqual(b[0], 2.0)
|
|
self.assertEqual(b[1], 2.0)
|
|
|
|
|
|
class TestEagerTensorIndex(unittest.TestCase):
|
|
def test__index__with_0size_tensor(self):
|
|
with dygraph_guard():
|
|
x = paddle.randn([0])
|
|
l = [1, 2, 3]
|
|
with self.assertRaisesRegex(
|
|
AssertionError,
|
|
"only one element variable can be converted to python index.",
|
|
):
|
|
l[x]
|
|
|
|
def test__index__with_non_scalar_tensor(self):
|
|
with dygraph_guard():
|
|
l = [1, 2, 3]
|
|
x = paddle.to_tensor([1]).reshape(1, 1, 1)
|
|
self.assertEqual(l[x], l[x.item()])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|