wehub-resource-sync
393 lines
15 KiB
Python
393 lines
15 KiB
Python
# Copyright (c) 2025 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 unittest
|
|
from itertools import product
|
|
|
|
import numpy as np
|
|
from op_test import get_device, get_device_place, is_custom_device
|
|
from utils import dygraph_guard
|
|
|
|
import paddle
|
|
from paddle.base.layer_helper import LayerHelper
|
|
from paddle.static import InputSpec, Program, program_guard
|
|
|
|
|
|
class TestTensorCreation(unittest.TestCase):
|
|
def setUp(self):
|
|
self.devices = [paddle.CPUPlace(), "cpu"]
|
|
if paddle.device.is_compiled_with_cuda() or is_custom_device():
|
|
self.devices.append(get_device_place())
|
|
self.devices.append(get_device())
|
|
self.devices.append(get_device(True))
|
|
if paddle.device.is_compiled_with_xpu():
|
|
self.devices.append(paddle.XPUPlace(0))
|
|
if paddle.device.is_compiled_with_ipu():
|
|
self.devices.append(paddle.device.IPUPlace())
|
|
|
|
self.requires_grads = [True, False]
|
|
self.dtypes = [None, paddle.float32]
|
|
self.pin_memories = [False]
|
|
if (
|
|
paddle.device.is_compiled_with_cuda()
|
|
and not paddle.device.is_compiled_with_rocm()
|
|
):
|
|
self.pin_memories.append(True)
|
|
|
|
def test_arange(self):
|
|
for device, requires_grad, dtype, pin_memory in product(
|
|
self.devices, self.requires_grads, self.dtypes, self.pin_memories
|
|
):
|
|
if (
|
|
device
|
|
not in [
|
|
get_device(),
|
|
get_device(True),
|
|
get_device_place()
|
|
if (
|
|
paddle.device.is_compiled_with_cuda()
|
|
or is_custom_device()
|
|
)
|
|
else None,
|
|
paddle.XPUPlace(0)
|
|
if paddle.device.is_compiled_with_xpu()
|
|
else None,
|
|
]
|
|
and pin_memory
|
|
):
|
|
continue # skip
|
|
|
|
with dygraph_guard():
|
|
x = paddle.arange(
|
|
3.14,
|
|
5.9,
|
|
1.11,
|
|
dtype=dtype,
|
|
requires_grad=requires_grad,
|
|
device=device,
|
|
pin_memory=pin_memory,
|
|
)
|
|
if pin_memory:
|
|
self.assertTrue("pinned" in str(x.place))
|
|
if (
|
|
not paddle.device.is_compiled_with_xpu()
|
|
and isinstance(device, paddle.framework.core.Place)
|
|
and not pin_memory
|
|
):
|
|
self.assertEqual(x.place, device)
|
|
self.assertEqual(x.stop_gradient, not requires_grad)
|
|
if isinstance(dtype, paddle.dtype):
|
|
self.assertEqual(x.dtype, dtype)
|
|
st_f = paddle.jit.to_static(
|
|
paddle.arange, full_graph=True, backend=None
|
|
)
|
|
x = st_f(
|
|
3.14,
|
|
5.9,
|
|
1.11,
|
|
dtype=dtype,
|
|
requires_grad=requires_grad,
|
|
device=device,
|
|
)
|
|
if not paddle.device.is_compiled_with_xpu() and isinstance(
|
|
device, paddle.framework.core.Place
|
|
):
|
|
self.assertEqual(x.place, device)
|
|
self.assertEqual(x.stop_gradient, not requires_grad)
|
|
if isinstance(dtype, paddle.dtype):
|
|
self.assertEqual(x.dtype, dtype)
|
|
|
|
def test_range(self):
|
|
def range_manual(start, end, step, dtype, device, requires_grad):
|
|
if end is None:
|
|
end = start
|
|
start = 0
|
|
if dtype is None:
|
|
dtype = paddle.get_default_dtype()
|
|
size_ = int(np.abs(np.trunc((end - start) / step))) + 1
|
|
out = paddle.empty([size_])
|
|
|
|
for i in range(size_):
|
|
out[i] = start + i * step
|
|
|
|
out = out.to(device=device, dtype=dtype)
|
|
out.stop_gradient = not requires_grad
|
|
return out
|
|
|
|
for device, requires_grad, dtype in product(
|
|
self.devices, self.requires_grads, self.dtypes
|
|
):
|
|
with dygraph_guard():
|
|
for start, end, step in [
|
|
(0, 0, 1),
|
|
(0, 5, 1),
|
|
(2, 7, 2),
|
|
(5, None, 1),
|
|
(0, 1, 0.1),
|
|
(-1.1, -3.7, -0.09),
|
|
(-1.1, -3.7, -0.10001),
|
|
(-1.1, -3.7, -0.9999),
|
|
]:
|
|
if np.abs(step) < 1 and dtype in [
|
|
paddle.int32,
|
|
"int32",
|
|
paddle.int64,
|
|
"int64",
|
|
]:
|
|
with self.assertRaises(ValueError):
|
|
x = paddle.range(
|
|
start,
|
|
end,
|
|
step,
|
|
dtype=dtype,
|
|
device=device,
|
|
requires_grad=requires_grad,
|
|
)
|
|
continue
|
|
else:
|
|
x = paddle.range(
|
|
start,
|
|
end,
|
|
step,
|
|
dtype=dtype,
|
|
device=device,
|
|
requires_grad=requires_grad,
|
|
)
|
|
x_ref = range_manual(
|
|
start, end, step, dtype, device, requires_grad
|
|
)
|
|
self.assertEqual(x.place, x_ref.place)
|
|
self.assertEqual(x.dtype, x_ref.dtype)
|
|
self.assertEqual(x.stop_gradient, x_ref.stop_gradient)
|
|
np.testing.assert_allclose(
|
|
x.numpy(),
|
|
x_ref.numpy(),
|
|
1e-6,
|
|
1e-6,
|
|
err_msg=f"[FAILED] wrong result when testing: range({start},{end},{step})",
|
|
)
|
|
|
|
def wrapped_range(
|
|
start, end, step, dtype, device, requires_grad
|
|
):
|
|
return paddle.range(
|
|
start,
|
|
end,
|
|
step,
|
|
dtype,
|
|
device=device,
|
|
requires_grad=requires_grad,
|
|
)
|
|
|
|
st_f = paddle.jit.to_static(
|
|
wrapped_range, full_graph=True, backend=None
|
|
)
|
|
x = st_f(
|
|
start,
|
|
end,
|
|
step,
|
|
dtype,
|
|
device=device,
|
|
requires_grad=requires_grad,
|
|
)
|
|
if (
|
|
isinstance(device, paddle.framework.core.Place)
|
|
# skip xpu for unknown reason
|
|
and not (
|
|
isinstance(
|
|
device, paddle.framework.core.XPUPlace
|
|
)
|
|
or is_custom_device()
|
|
)
|
|
):
|
|
self.assertEqual(x.place, x_ref.place)
|
|
self.assertEqual(x.dtype, x_ref.dtype)
|
|
self.assertEqual(x.stop_gradient, x_ref.stop_gradient)
|
|
np.testing.assert_allclose(
|
|
x.numpy(),
|
|
x_ref.numpy(),
|
|
1e-6,
|
|
1e-6,
|
|
err_msg=f"[FAILED] wrong result when testing: range({start},{end},{step})",
|
|
)
|
|
|
|
def wrapped_range(start, end, step):
|
|
return paddle.range(
|
|
start,
|
|
end,
|
|
step,
|
|
dtype,
|
|
device=device,
|
|
requires_grad=requires_grad,
|
|
)
|
|
|
|
if end is None:
|
|
st_f = paddle.jit.to_static(
|
|
wrapped_range,
|
|
input_spec=[
|
|
InputSpec([-1]),
|
|
None,
|
|
InputSpec([-1]),
|
|
],
|
|
full_graph=True,
|
|
backend=None,
|
|
)
|
|
else:
|
|
st_f = paddle.jit.to_static(
|
|
wrapped_range,
|
|
input_spec=[
|
|
InputSpec([-1]),
|
|
InputSpec([-1]),
|
|
InputSpec([-1]),
|
|
],
|
|
full_graph=True,
|
|
backend=None,
|
|
)
|
|
|
|
x = st_f(
|
|
paddle.to_tensor(start),
|
|
paddle.to_tensor(end) if end is not None else None,
|
|
paddle.to_tensor(step),
|
|
)
|
|
if (
|
|
isinstance(device, paddle.framework.core.Place)
|
|
# skip xpu for unknown reason
|
|
and not (
|
|
isinstance(
|
|
device, paddle.framework.core.XPUPlace
|
|
)
|
|
or is_custom_device()
|
|
)
|
|
):
|
|
self.assertEqual(x.place, x_ref.place)
|
|
self.assertEqual(x.dtype, x_ref.dtype)
|
|
self.assertEqual(x.stop_gradient, x_ref.stop_gradient)
|
|
np.testing.assert_allclose(
|
|
x.numpy(),
|
|
x_ref.numpy(),
|
|
1e-6,
|
|
1e-6,
|
|
err_msg=f"[FAILED] wrong result when testing: range({start},{end},{step})",
|
|
)
|
|
|
|
|
|
class TestCreationOut(unittest.TestCase):
|
|
def setUp(self):
|
|
self.x_np = np.random.rand(3, 4).astype(np.float32)
|
|
self.constant = 3.14
|
|
|
|
def test_arange(self):
|
|
x = paddle.randn([2, 2])
|
|
t = paddle.empty_like(x)
|
|
y = paddle.arange(-1.1, 3.4, 0.1, out=t, requires_grad=True)
|
|
np.testing.assert_allclose(
|
|
t.numpy(), np.arange(-1.1, 3.4, 0.1), 1e-6, 1e-6
|
|
)
|
|
np.testing.assert_allclose(
|
|
y.numpy(), np.arange(-1.1, 3.4, 0.1), 1e-6, 1e-6
|
|
)
|
|
self.assertEqual(t.data_ptr(), y.data_ptr())
|
|
self.assertEqual(y.stop_gradient, False)
|
|
self.assertEqual(t.stop_gradient, False)
|
|
|
|
def test_range(self):
|
|
x = paddle.randn([2, 2])
|
|
t = paddle.empty_like(x)
|
|
y = paddle.range(-1.1, 3.4, 0.1, out=t, requires_grad=True)
|
|
self.assertEqual(t.data_ptr(), y.data_ptr())
|
|
self.assertEqual(y.stop_gradient, False)
|
|
self.assertEqual(t.stop_gradient, False)
|
|
|
|
|
|
class TestRangeV2LegacyInferMeta(unittest.TestCase):
|
|
"""
|
|
Test that RangeTensorInferMetaLegacy is triggered via legacy static graph path.
|
|
- TestTensorCreation.test_range (above) calls paddle.range() in
|
|
dynamic graph mode, which triggers RangeTensorInferMeta (with dtype param).
|
|
- NO existing test triggers RangeTensorInferMetaLegacy (no dtype param),
|
|
because paddle.range() has no old static graph fallback like
|
|
paddle.arange() does (which falls back to append_op(type='range')
|
|
→ mapped to the 'arange' op, not 'range_v2').
|
|
- To trigger RangeTensorInferMetaLegacy, we use append_op(type='range_v2')
|
|
under static graph mode).
|
|
"""
|
|
|
|
def range_manual(self, start, end, step, dtype):
|
|
size_ = int(np.abs(np.trunc((end - start) / step))) + 1
|
|
out = np.empty([size_], dtype=dtype)
|
|
for i in range(size_):
|
|
out[i] = start + i * step
|
|
return out
|
|
|
|
def test_range_v2_legacy(self):
|
|
paddle.enable_static()
|
|
try:
|
|
test_cases = [
|
|
(0, 5, 1),
|
|
(2, 7, 2),
|
|
(0, 1, 0.1),
|
|
(10, 1, -2),
|
|
(-1, -10, -2),
|
|
]
|
|
for start_val, end_val, step_val in test_cases:
|
|
with (
|
|
paddle.pir_utils.OldIrGuard(),
|
|
program_guard(Program(), Program()),
|
|
):
|
|
start = paddle.static.data(
|
|
name='start', shape=[1], dtype='float32'
|
|
)
|
|
end = paddle.static.data(
|
|
name='end', shape=[1], dtype='float32'
|
|
)
|
|
step = paddle.static.data(
|
|
name='step', shape=[1], dtype='float32'
|
|
)
|
|
|
|
helper = LayerHelper('range_v2')
|
|
out = helper.create_variable_for_type_inference(
|
|
dtype='float32'
|
|
)
|
|
helper.append_op(
|
|
type='range_v2',
|
|
inputs={'Start': start, 'End': end, 'Step': step},
|
|
outputs={'Out': out},
|
|
)
|
|
self.assertEqual(out.shape, (-1,))
|
|
|
|
exe = paddle.static.Executor(paddle.CPUPlace())
|
|
(result,) = exe.run(
|
|
feed={
|
|
'start': np.array([start_val], dtype='float32'),
|
|
'end': np.array([end_val], dtype='float32'),
|
|
'step': np.array([step_val], dtype='float32'),
|
|
},
|
|
fetch_list=[out],
|
|
)
|
|
expected = self.range_manual(
|
|
start_val, end_val, step_val, 'float32'
|
|
)
|
|
np.testing.assert_allclose(
|
|
result,
|
|
expected,
|
|
rtol=1e-6,
|
|
atol=1e-6,
|
|
err_msg=f"[FAILED] range_v2({start_val},{end_val},{step_val})",
|
|
)
|
|
finally:
|
|
paddle.disable_static()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|