wehub-resource-sync
2825 lines
102 KiB
Python
2825 lines
102 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 os
|
|
import subprocess
|
|
import sys
|
|
import textwrap
|
|
import unittest
|
|
|
|
import numpy as np
|
|
|
|
import paddle
|
|
import paddle.nn.functional as F
|
|
|
|
|
|
# Edit By AI Agent
|
|
# Test nextafter compatibility
|
|
@unittest.skipIf(
|
|
paddle.is_compiled_with_custom_device('iluvatar_gpu'),
|
|
"skip iluvatar_gpu which not register nextafter kernel",
|
|
)
|
|
class TestNextafterAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('float32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.nextafter(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.nextafter(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.nextafter(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.nextafter(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(x)
|
|
out6 = paddle.nextafter(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.nextafter(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.nextafter(other=y)
|
|
|
|
ref_out = np.nextafter(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.nextafter(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.nextafter(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.nextafter(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.nextafter(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.nextafter(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.nextafter(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
# Test round_ compatibility (inplace API)
|
|
class TestRoundInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
self.np_x = np.array([1.5, 2.3, 3.7, -1.2, -2.8]).astype('float32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
"""Test round_ inplace API in dynamic mode"""
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Tensor method - Paddle positional args
|
|
x1 = x.clone()
|
|
out1 = x1.round_(0)
|
|
assert out1 is x1
|
|
|
|
# 2. Tensor method - Paddle keyword args
|
|
x2 = x.clone()
|
|
out2 = x2.round_(decimals=1)
|
|
assert out2 is x2
|
|
|
|
# 3. Paddle function - positional args
|
|
x3 = x.clone()
|
|
out3 = paddle.round_(x3, 1)
|
|
assert out3 is x3
|
|
|
|
# 4. Paddle function - keyword args
|
|
x4 = x.clone()
|
|
out4 = paddle.round_(x4, decimals=-1)
|
|
assert out4 is x4
|
|
|
|
# Verify all outputs
|
|
np.testing.assert_allclose(out1.numpy(), np.round(self.np_x), rtol=1e-6)
|
|
np.testing.assert_allclose(
|
|
out2.numpy(), np.around(self.np_x, decimals=1), rtol=1e-6
|
|
)
|
|
np.testing.assert_allclose(
|
|
out3.numpy(), np.around(self.np_x, decimals=1), rtol=1e-6
|
|
)
|
|
np.testing.assert_allclose(
|
|
out4.numpy(), np.around(self.np_x, decimals=-1), rtol=1e-6
|
|
)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test erf compatibility
|
|
class TestErfAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
self.np_x = np.array([-0.4, -0.2, 0.0, 0.1, 0.3]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.erf(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.erf(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.erf(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(x)
|
|
out5 = paddle.erf(x, out=out4)
|
|
# 6. Tensor method - positional args
|
|
out6 = x.erf()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.array(
|
|
[-0.42839241, -0.22270259, 0.0, 0.11246292, 0.32862678]
|
|
).astype('float32')
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(
|
|
out.numpy(), ref_out, rtol=1e-5, atol=1e-5
|
|
)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
"""Test erf API in static mode"""
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.erf(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.erf(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.erf(input=x)
|
|
# 4. Tensor method - positional args
|
|
out4 = x.erf()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs match with loop
|
|
ref_out = np.array(
|
|
[-0.42839241, -0.22270259, 0.0, 0.11246292, 0.32862678]
|
|
).astype('float32')
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
|
|
|
|
|
# Test erf_ inplace compatibility
|
|
class TestErfInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
self.np_x = np.array([-0.4, -0.2, 0.0, 0.1, 0.3]).astype('float32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
ref_out = np.array(
|
|
[-0.42839241, -0.22270259, 0.0, 0.11246292, 0.32862678]
|
|
).astype('float32')
|
|
|
|
# 1. Tensor method - positional args
|
|
x1 = x.clone()
|
|
out1 = x1.erf_()
|
|
assert out1 is x1
|
|
|
|
# 2. Paddle function - positional args
|
|
x2 = x.clone()
|
|
out2 = paddle.erf_(x2)
|
|
assert out2 is x2
|
|
|
|
# Verify all outputs with loop
|
|
for out in [out1, out2]:
|
|
np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test iinfo compatibility
|
|
class TestIinfoAPI(unittest.TestCase):
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.iinfo(paddle.int32)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.iinfo(dtype=paddle.int32)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.iinfo(type=paddle.int32)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3]:
|
|
assert out.min == -2147483648
|
|
assert out.max == 2147483647
|
|
assert out.bits == 32
|
|
assert str(out.dtype) == 'int32'
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
# iinfo is a compile-time function, same in static mode
|
|
out1 = paddle.iinfo(paddle.int32)
|
|
out2 = paddle.iinfo(dtype=paddle.int32)
|
|
out3 = paddle.iinfo(type=paddle.int32)
|
|
|
|
for out in [out1, out2, out3]:
|
|
assert out.min == -2147483648
|
|
assert out.max == 2147483647
|
|
|
|
|
|
# Test additional paddle.dtype.itemsize compatibility.
|
|
class TestDtypeItemsizeExtendedAPI(unittest.TestCase):
|
|
EXPECTED = (
|
|
'float16',
|
|
'bfloat16',
|
|
'float32',
|
|
'float64',
|
|
'complex64',
|
|
'complex128',
|
|
'int8',
|
|
'int16',
|
|
'int32',
|
|
'int64',
|
|
'uint8',
|
|
'uint16',
|
|
'uint32',
|
|
'uint64',
|
|
'bool',
|
|
'float8_e4m3fn',
|
|
'float8_e5m2',
|
|
)
|
|
|
|
def test_dtype_str(self):
|
|
for name in self.EXPECTED:
|
|
with self.subTest(dtype=name):
|
|
self.assertEqual(str(getattr(paddle, name)), f'paddle.{name}')
|
|
|
|
def test_int_alias_matches(self):
|
|
self.assertEqual(paddle.int.itemsize, paddle.int32.itemsize)
|
|
|
|
|
|
class TestFloatingDtypeAPI(unittest.TestCase):
|
|
EXPECTED = {
|
|
'float16': (16, 0.0009765625, -65504.0, 65504.0, 6.103515625e-05),
|
|
'bfloat16': (
|
|
16,
|
|
0.0078125,
|
|
-3.3895313892515355e38,
|
|
3.3895313892515355e38,
|
|
1.1754943508222875e-38,
|
|
),
|
|
'float32': (
|
|
32,
|
|
1.1920928955078125e-07,
|
|
-3.4028234663852886e38,
|
|
3.4028234663852886e38,
|
|
1.1754943508222875e-38,
|
|
),
|
|
'float64': (
|
|
64,
|
|
2.220446049250313e-16,
|
|
-1.7976931348623157e308,
|
|
1.7976931348623157e308,
|
|
2.2250738585072014e-308,
|
|
),
|
|
'float8_e4m3fn': (8, 0.125, -448.0, 448.0, 0.015625),
|
|
'float8_e5m2': (8, 0.25, -57344.0, 57344.0, 6.103515625e-05),
|
|
}
|
|
|
|
def check_finfo(self, info, name):
|
|
bits, eps, min_value, max_value, tiny = self.EXPECTED[name]
|
|
self.assertEqual(info.bits, bits)
|
|
self.assertEqual(str(info.dtype), name)
|
|
self.assertEqual(info.eps, eps)
|
|
self.assertEqual(info.min, min_value)
|
|
self.assertEqual(info.max, max_value)
|
|
self.assertEqual(info.smallest_normal, tiny)
|
|
self.assertEqual(info.tiny, tiny)
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
for name in self.EXPECTED:
|
|
dtype = getattr(paddle, name)
|
|
with self.subTest(dtype=name):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.finfo(dtype)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.finfo(dtype=dtype)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.finfo(type=dtype)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3]:
|
|
self.check_finfo(out, name)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
for name in self.EXPECTED:
|
|
dtype = getattr(paddle, name)
|
|
with self.subTest(dtype=name):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.finfo(dtype)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.finfo(dtype=dtype)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.finfo(type=dtype)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3]:
|
|
self.check_finfo(out, name)
|
|
|
|
|
|
class TestIntegerDtypeAPI(unittest.TestCase):
|
|
EXPECTED = {
|
|
'uint8': (0, 255, 8),
|
|
'uint16': (0, 65535, 16),
|
|
'uint32': (0, 4294967295, 32),
|
|
'uint64': (0, 18446744073709551615, 64),
|
|
'int8': (-128, 127, 8),
|
|
'int16': (-32768, 32767, 16),
|
|
'int32': (-2147483648, 2147483647, 32),
|
|
'int64': (-9223372036854775808, 9223372036854775807, 64),
|
|
}
|
|
|
|
def check_iinfo(self, info, name):
|
|
min_value, max_value, bits = self.EXPECTED[name]
|
|
self.assertEqual(info.min, min_value)
|
|
self.assertEqual(info.max, max_value)
|
|
self.assertEqual(info.bits, bits)
|
|
self.assertEqual(str(info.dtype), name)
|
|
self.assertIn(f'max={max_value}', repr(info))
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
for name in self.EXPECTED:
|
|
dtype = getattr(paddle, name)
|
|
with self.subTest(dtype=name):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.iinfo(dtype)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.iinfo(dtype=dtype)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.iinfo(type=dtype)
|
|
out4 = paddle.iinfo(name)
|
|
out5 = paddle.iinfo(np.dtype(name))
|
|
out6 = paddle.iinfo(getattr(np, name))
|
|
out7 = paddle.iinfo(name.upper())
|
|
out8 = paddle.iinfo(f" {name} ")
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
self.check_iinfo(out, name)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
for name in self.EXPECTED:
|
|
dtype = getattr(paddle, name)
|
|
with self.subTest(dtype=name):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.iinfo(dtype)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.iinfo(dtype=dtype)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.iinfo(type=dtype)
|
|
out4 = paddle.iinfo(name)
|
|
out5 = paddle.iinfo(np.dtype(name))
|
|
out6 = paddle.iinfo(getattr(np, name))
|
|
out7 = paddle.iinfo(name.upper())
|
|
out8 = paddle.iinfo(f" {name} ")
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
self.check_iinfo(out, name)
|
|
|
|
|
|
class TestLegacyVarTypeDtypeAPI(unittest.TestCase):
|
|
def test_uint_iinfo_with_pir_disabled(self):
|
|
code = textwrap.dedent(
|
|
"""
|
|
import numpy as np
|
|
import paddle
|
|
|
|
expected = {
|
|
'uint16': (0, 65535, 16),
|
|
'uint32': (0, 4294967295, 32),
|
|
'uint64': (0, 18446744073709551615, 64),
|
|
}
|
|
assert str(paddle.bfloat16) == 'paddle.bfloat16'
|
|
for name, (min_value, max_value, bits) in expected.items():
|
|
dtype = getattr(paddle, name)
|
|
assert str(dtype) == f'paddle.{name}'
|
|
for arg in (
|
|
dtype,
|
|
name,
|
|
np.dtype(name),
|
|
getattr(np, name),
|
|
name.upper(),
|
|
f" {name} ",
|
|
):
|
|
info = paddle.iinfo(arg)
|
|
assert info.min == min_value
|
|
assert info.max == max_value
|
|
assert info.bits == bits
|
|
assert str(info.dtype) == name
|
|
"""
|
|
)
|
|
env = os.environ.copy()
|
|
env["FLAGS_enable_pir_api"] = "0"
|
|
subprocess.run(
|
|
[sys.executable, "-c", code],
|
|
check=True,
|
|
env=env,
|
|
capture_output=True,
|
|
text=True,
|
|
)
|
|
|
|
|
|
# Test angle compatibility
|
|
class TestAngleAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
np_x_real = np.random.randn(5, 6).astype('float32')
|
|
np_x_imag = np.random.randn(5, 6).astype('float32')
|
|
self.np_x = np_x_real + 1j * np_x_imag
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.angle(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.angle(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.angle(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.angle(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.angle()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.angle(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(
|
|
ref_out, out.numpy(), rtol=1e-5, atol=1e-5
|
|
)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='complex64')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.angle(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.angle(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.angle(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.angle()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.angle(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-5)
|
|
|
|
|
|
# Test atan compatibility
|
|
class TestAtanAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.atan(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.atan(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.atan(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(x)
|
|
out5 = paddle.atan(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.atan()
|
|
|
|
ref_out = np.arctan(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
|
|
out1 = paddle.atan(x)
|
|
out2 = paddle.atan(x=x)
|
|
out3 = paddle.atan(input=x)
|
|
out4 = x.atan()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.arctan(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-6)
|
|
|
|
|
|
class TestAtan2API(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.atan2(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.atan2(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.atan2(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.atan2(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
out6 = paddle.atan2(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.atan2(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.atan2(other=y)
|
|
|
|
# Verify all outputs
|
|
ref_out = np.arctan2(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.atan2(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.atan2(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.atan2(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.atan2(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.atan2(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.arctan2(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-6)
|
|
|
|
|
|
class TestHypotAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.hypot(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.hypot(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.hypot(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.hypot(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(x)
|
|
out6 = paddle.hypot(x, y, out=out5)
|
|
assert out5 is out6
|
|
# 7. Tensor method - positional args
|
|
out7 = x.hypot(y)
|
|
# 8. Tensor method - keyword args (PyTorch alias)
|
|
out8 = x.hypot(other=y)
|
|
|
|
ref_out = np.hypot(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), atol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.hypot(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.hypot(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.hypot(input=x, other=y)
|
|
# 4. Tensor method - positional args
|
|
out4 = x.hypot(y)
|
|
# 5. Tensor method - keyword args (PyTorch alias)
|
|
out5 = x.hypot(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.hypot(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, atol=1e-6)
|
|
|
|
|
|
class TestHypotInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.hypot(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().hypot_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().hypot_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().hypot_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.hypot_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.hypot_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.hypot_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), atol=1e-6)
|
|
|
|
|
|
# Test fmax compatibility
|
|
class TestFmaxAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.fmax(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.fmax(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.fmax(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.fmax(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(x)
|
|
out6 = paddle.fmax(x, y, out=out5)
|
|
# 7. Tensor method - positional args
|
|
out7 = x.fmax(y)
|
|
# 8. Tensor method - keyword args (PyTorch alias)
|
|
out8 = x.fmax(other=y)
|
|
|
|
ref_out = np.fmax(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.fmax(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.fmax(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.fmax(input=x, other=y)
|
|
# 4. Tensor method - positional args
|
|
out4 = x.fmax(y)
|
|
# 5. Tensor method - keyword args (PyTorch alias)
|
|
out5 = x.fmax(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
ref_out = np.fmax(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
# Test fmin compatibility
|
|
class TestFminAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.fmin(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.fmin(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.fmin(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.fmin(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(x)
|
|
out6 = paddle.fmin(x, y, out=out5)
|
|
# 7. Tensor method - positional args
|
|
out7 = x.fmin(y)
|
|
# 8. Tensor method - keyword args (PyTorch alias)
|
|
out8 = x.fmin(other=y)
|
|
|
|
ref_out = np.fmin(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.fmin(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.fmin(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.fmin(input=x, other=y)
|
|
# 4. Tensor method - positional args
|
|
out4 = x.fmin(y)
|
|
# 5. Tensor method - keyword args (PyTorch alias)
|
|
out5 = x.fmin(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
ref_out = np.fmin(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
# Test bincount compatibility
|
|
class TestBincountAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [10]).astype('int64')
|
|
self.np_weights = np.random.random([10]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
weights = paddle.to_tensor(self.np_weights)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bincount(x, weights, 6)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bincount(x=x, weights=weights, minlength=6)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bincount(input=x, weights=weights, minlength=6)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bincount(x, weights=weights, minlength=6)
|
|
|
|
ref_out = np.bincount(self.np_x, weights=self.np_weights, minlength=6)
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[10], dtype='int64')
|
|
weights = paddle.static.data(
|
|
name="weights", shape=[10], dtype='float32'
|
|
)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bincount(x, weights, 6)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bincount(x=x, weights=weights, minlength=6)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bincount(input=x, weights=weights, minlength=6)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "weights": self.np_weights},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
|
|
ref_out = np.bincount(
|
|
self.np_x, weights=self.np_weights, minlength=6
|
|
)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(ref_out, out)
|
|
|
|
|
|
# Test diag compatibility
|
|
class TestDiagAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(3, 3).astype('float32')
|
|
self.np_v = np.random.randn(3).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
v = paddle.to_tensor(self.np_v)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.diag(x, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.diag(x=x, offset=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.diag(input=x, diagonal=1)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.diag(x, offset=1)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(v)
|
|
out6 = paddle.diag(v, out=out5)
|
|
# 7. Tensor method - positional args
|
|
out7 = x.diag(1)
|
|
# 8. Tensor method - keyword args (PyTorch alias)
|
|
out8 = x.diag(diagonal=1)
|
|
|
|
ref_diag_v = np.diag(self.np_v)
|
|
ref_diag_x_offset = np.diag(self.np_x, 1)
|
|
|
|
for out in [out1, out2, out3, out4, out7, out8]:
|
|
np.testing.assert_allclose(ref_diag_x_offset, out.numpy())
|
|
np.testing.assert_allclose(ref_diag_v, out5.numpy())
|
|
np.testing.assert_allclose(ref_diag_v, out6.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3, 3], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.diag(x, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.diag(x=x, offset=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.diag(input=x, diagonal=1)
|
|
# 4. Tensor method - positional args
|
|
out4 = x.diag(1)
|
|
# 5. Tensor method - keyword args (PyTorch alias)
|
|
out5 = x.diag(diagonal=1)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
ref_out = np.diag(self.np_x, 1)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
# Test heaviside compatibility
|
|
class TestHeavisideAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(5, 6).astype('float32')
|
|
self.np_y = np.random.randn(5, 6).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.heaviside(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.heaviside(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.heaviside(input=x, values=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.heaviside(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
out6 = paddle.heaviside(x, y, out=out5)
|
|
# 7. Tensor method - positional args
|
|
out7 = x.heaviside(y)
|
|
# 8. Tensor method - keyword args (PyTorch alias)
|
|
out8 = x.heaviside(values=y)
|
|
|
|
# Verify all outputs
|
|
ref_out = np.heaviside(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.heaviside(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.heaviside(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.heaviside(input=x, values=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.heaviside(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.heaviside(values=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.heaviside(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
class TestAsinhAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.asinh(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.asinh(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.asinh(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.asinh(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.asinh()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.arcsinh(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.asinh(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.asinh(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.asinh(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.asinh()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.arcsinh(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-6)
|
|
|
|
|
|
class TestReciprocalAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(1, 8, [5, 6]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.reciprocal(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.reciprocal(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.reciprocal(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.reciprocal(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.reciprocal()
|
|
|
|
# Verify all outputs
|
|
ref_out = 1.0 / self.np_x
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.reciprocal(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.reciprocal(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.reciprocal(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.reciprocal()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = 1.0 / self.np_x
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
class TestSquareAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.square(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.square(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.square(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.square(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.square()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.square(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.square(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.square(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.square(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.square()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.square(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out)
|
|
|
|
|
|
# Test masked_fill compatibility
|
|
class TestMaskedFillAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(1, 10, [3, 3]).astype('float32')
|
|
self.np_mask = np.random.randint(0, 2, [3, 3]).astype(bool)
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
mask = paddle.to_tensor(self.np_mask)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.masked_fill(x, mask, 0.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.masked_fill(x=x, mask=mask, value=0.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.masked_fill(input=x, mask=mask, value=0.0)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.masked_fill(x, mask=mask, value=0.0)
|
|
# 5. Tensor method - positional args
|
|
out5 = x.masked_fill(mask, 0.0)
|
|
# 6. Tensor method - keyword args (PyTorch alias)
|
|
out6 = x.masked_fill(mask=mask, value=0.0)
|
|
|
|
# Verify all outputs are equal
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(out1.numpy(), out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3, 3], dtype='float32')
|
|
mask = paddle.static.data(name="mask", shape=[3, 3], dtype='bool')
|
|
|
|
# Position args
|
|
out1 = paddle.masked_fill(x, mask, 0.0)
|
|
# Paddle keyword args
|
|
out2 = paddle.masked_fill(x=x, mask=mask, value=0.0)
|
|
# Torch keyword args (input alias)
|
|
out3 = paddle.masked_fill(input=x, mask=mask, value=0.0)
|
|
# Tensor method
|
|
out4 = x.masked_fill(mask, 0.0)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "mask": self.np_mask},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs are equal
|
|
for i in range(1, len(fetches)):
|
|
np.testing.assert_allclose(fetches[0], fetches[i])
|
|
|
|
|
|
class TestTanAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.tan(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tan(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.tan(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.tan(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.tan()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.tan(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='float32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.tan(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tan(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.tan(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.tan()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.tan(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, ref_out, rtol=1e-6)
|
|
|
|
|
|
# Test bitwise_and compatibility
|
|
class TestBitwiseAndAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_and(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_and(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_and(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bitwise_and(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(x)
|
|
out6 = paddle.bitwise_and(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.bitwise_and(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.bitwise_and(other=y)
|
|
|
|
ref_out = np.bitwise_and(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_and(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_and(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_and(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.bitwise_and(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.bitwise_and(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
ref_out = np.bitwise_and(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_or compatibility
|
|
class TestBitwiseOrAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_or(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_or(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_or(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bitwise_or(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
out6 = paddle.bitwise_or(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.bitwise_or(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.bitwise_or(other=y)
|
|
|
|
ref_out = np.bitwise_or(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_or(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_or(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_or(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.bitwise_or(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.bitwise_or(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.bitwise_or(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_not compatibility
|
|
class TestBitwiseNotAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_not(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_not(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_not(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty_like(out1)
|
|
out5 = paddle.bitwise_not(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.bitwise_not()
|
|
|
|
ref_out = np.bitwise_not(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_not(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_not(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_not(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.bitwise_not()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.bitwise_not(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_xor compatibility
|
|
class TestBitwiseXorAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_xor(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_xor(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_xor(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bitwise_xor(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
out6 = paddle.bitwise_xor(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.bitwise_xor(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.bitwise_xor(other=y)
|
|
|
|
ref_out = np.bitwise_xor(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_xor(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_xor(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_xor(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.bitwise_xor(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.bitwise_xor(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.bitwise_xor(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_and_ inplace compatibility
|
|
class TestBitwiseAndInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.bitwise_and(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_and_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().bitwise_and_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().bitwise_and_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.bitwise_and_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.bitwise_and_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.bitwise_and_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
# Test bitwise_or_ inplace compatibility
|
|
class TestBitwiseOrInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.bitwise_or(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_or_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().bitwise_or_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().bitwise_or_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.bitwise_or_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.bitwise_or_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.bitwise_or_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
# Test bitwise_xor_ inplace compatibility
|
|
class TestBitwiseXorInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.bitwise_xor(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_xor_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().bitwise_xor_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().bitwise_xor_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.bitwise_xor_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.bitwise_xor_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.bitwise_xor_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
# Test bitwise_not_ inplace compatibility
|
|
class TestBitwiseNotInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(0, 8, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
ref_out = np.bitwise_not(self.np_x)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_not_()
|
|
# 2. Tensor method - keyword args
|
|
out2 = x.clone().bitwise_not_()
|
|
# 3. Paddle function - positional args
|
|
out3 = paddle.bitwise_not_(x.clone())
|
|
# 4. Paddle function - keyword args (PyTorch alias)
|
|
out4 = paddle.bitwise_not_(input=x.clone())
|
|
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
class TestCdistAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.rand(3, 5, 4).astype('float32')
|
|
self.np_y = np.random.rand(3, 2, 4).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
out1 = paddle.cdist(x, y)
|
|
out2 = paddle.cdist(x=x, y=y)
|
|
out3 = paddle.cdist(x1=x, x2=y)
|
|
out4 = paddle.cdist(x, y, p=2.0)
|
|
out5 = paddle.cdist(
|
|
x1=x,
|
|
x2=y,
|
|
p=2.0,
|
|
compute_mode='use_mm_for_euclid_dist_if_necessary',
|
|
)
|
|
for out in [out2, out3, out4, out5]:
|
|
np.testing.assert_allclose(out1.numpy(), out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3, 5, 4], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[3, 2, 4], dtype='float32')
|
|
out1 = paddle.cdist(x, y)
|
|
out2 = paddle.cdist(x=x, y=y)
|
|
out3 = paddle.cdist(x1=x, x2=y)
|
|
out4 = paddle.cdist(x, y, p=2.0)
|
|
out5 = paddle.cdist(
|
|
x1=x,
|
|
x2=y,
|
|
p=2.0,
|
|
compute_mode='use_mm_for_euclid_dist_if_necessary',
|
|
)
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(fetches[0], out)
|
|
|
|
def test_zero_size(self):
|
|
"""Test edge cases: r1==0, r2==0, c1==0."""
|
|
paddle.disable_static()
|
|
# r1==0 (3D batched)
|
|
x1 = paddle.to_tensor(np.random.rand(2, 0, 4).astype('float32'))
|
|
y1 = paddle.to_tensor(np.random.rand(2, 3, 4).astype('float32'))
|
|
out1 = paddle.cdist(x1, y1)
|
|
self.assertEqual(out1.shape, [2, 0, 3])
|
|
# r2==0 (2D non-batched)
|
|
x2 = paddle.to_tensor(np.random.rand(3, 4).astype('float32'))
|
|
y2 = paddle.to_tensor(np.random.rand(0, 4).astype('float32'))
|
|
out2 = paddle.cdist(x2, y2)
|
|
self.assertEqual(out2.shape, [3, 0])
|
|
# c1==0 (3D batched, should return zeros)
|
|
x3 = paddle.to_tensor(np.random.rand(2, 3, 0).astype('float32'))
|
|
y3 = paddle.to_tensor(np.random.rand(2, 2, 0).astype('float32'))
|
|
out3 = paddle.cdist(x3, y3)
|
|
self.assertEqual(out3.shape, [2, 3, 2])
|
|
np.testing.assert_allclose(out3.numpy(), 0.0)
|
|
paddle.enable_static()
|
|
|
|
|
|
class TestAddmmAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(2, 3).astype('float32')
|
|
self.np_x = np.random.rand(2, 4).astype('float32')
|
|
self.np_y = np.random.rand(4, 3).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = 1.0 * self.np_input + 1.0 * self.np_x @ self.np_y
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.addmm(input, x, y, 1.0, 1.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.addmm(input=input, x=x, y=y, beta=1.0, alpha=1.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.addmm(beta=1.0, alpha=1.0, input=input, mat1=x, mat2=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.addmm(input, x, y, beta=1.0, alpha=1.0)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(input)
|
|
out6 = paddle.addmm(input, x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = input.addmm(x, y, beta=1.0, alpha=1.0)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = input.addmm(mat1=x, mat2=y, beta=1.0, alpha=1.0)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_error(self):
|
|
"""Test invalid input dimensions that should raise ValueError."""
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# Test 3D input (invalid)
|
|
input_3d = paddle.to_tensor(np.random.rand(2, 2, 3).astype('float32'))
|
|
with self.assertRaises(ValueError):
|
|
paddle.addmm(input_3d, x, y)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
input = paddle.static.data(
|
|
name="input", shape=[2, 3], dtype='float32'
|
|
)
|
|
x = paddle.static.data(name="x", shape=[2, 4], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[4, 3], dtype='float32')
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.addmm(input, x, y, 1.0, 1.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.addmm(input=input, x=x, y=y, beta=1.0, alpha=1.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.addmm(beta=1, alpha=1, input=input, mat1=x, mat2=y)
|
|
# 4. Tensor method - args
|
|
out4 = input.addmm(x, y, beta=1.0, alpha=1.0)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = input.addmm(mat1=x, mat2=y, beta=1.0, alpha=1.0)
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"input": self.np_input, "x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = 1.0 * self.np_input + 1.0 * self.np_x @ self.np_y
|
|
for out in fetches:
|
|
np.testing.assert_allclose(ref_out, out, rtol=1e-6)
|
|
|
|
|
|
class TestAddmmInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(2, 3).astype('float32')
|
|
self.np_x = np.random.rand(2, 4).astype('float32')
|
|
self.np_y = np.random.rand(4, 3).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
out1 = paddle.addmm_(input.clone(), x, y, beta=1.0, alpha=1.0)
|
|
out2 = paddle.addmm_(input=input.clone(), x=x, y=y, beta=1.0, alpha=1.0)
|
|
out3 = paddle.addmm_(
|
|
input=input.clone(), mat1=x, mat2=y, beta=1.0, alpha=1.0
|
|
)
|
|
out4 = input.clone().addmm_(x, y, beta=1.0, alpha=1.0)
|
|
out5 = input.clone().addmm_(x=x, y=y, beta=1.0, alpha=1.0)
|
|
out6 = input.clone().addmm_(mat1=x, mat2=y, beta=1.0, alpha=1.0)
|
|
ref_out = 1.0 * self.np_input + 1.0 * self.np_x @ self.np_y
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
|
|
class TestLdexpInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(3, 4).astype('float32')
|
|
self.np_y = np.random.randint(-3, 4, [3, 4]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.ldexp(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().ldexp_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().ldexp_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().ldexp_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.ldexp_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.ldexp_(input=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.ldexp_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test imag property compatibility (PyTorch-style property access)
|
|
class TestImagPropertyAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
np_x_real = np.random.randn(5, 6).astype('float32')
|
|
np_x_imag = np.random.randn(5, 6).astype('float32')
|
|
self.np_x = np_x_real + 1j * np_x_imag
|
|
|
|
# will support future
|
|
def _test_dygraph_Compatibility(self):
|
|
"""Test imag as property (PyTorch style: x.imag)"""
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# PyTorch style: property access
|
|
imag_result = x.imag
|
|
self.assertIsInstance(imag_result, paddle.Tensor)
|
|
np.testing.assert_allclose(imag_result.numpy(), np.imag(self.np_x))
|
|
|
|
paddle.enable_static()
|
|
|
|
# will support future
|
|
def _test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3], dtype='complex64')
|
|
|
|
out = x.imag
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out],
|
|
)
|
|
np.testing.assert_allclose(fetches[0], np.imag(self.np_x))
|
|
|
|
|
|
# Test real property compatibility (PyTorch-style property access)
|
|
class TestRealPropertyAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
np_x_real = np.random.randn(5, 6).astype('float32')
|
|
np_x_imag = np.random.randn(5, 6).astype('float32')
|
|
self.np_x = np_x_real + 1j * np_x_imag
|
|
|
|
# will support future
|
|
def _test_dygraph_Compatibility(self):
|
|
"""Test real as property (PyTorch style: x.real)"""
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
real_result = x.real
|
|
self.assertIsInstance(real_result, paddle.Tensor)
|
|
np.testing.assert_allclose(real_result.numpy(), np.real(self.np_x))
|
|
|
|
paddle.enable_static()
|
|
|
|
# will support future
|
|
def _test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3], dtype='complex64')
|
|
out = x.real
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out],
|
|
)
|
|
np.testing.assert_allclose(fetches[0], np.real(self.np_x))
|
|
|
|
|
|
# Test baddbmm API compatibility (paddle.baddbmm and paddle.Tensor.baddbmm)
|
|
class TestBaddbmmAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3, 2, 3).astype('float32')
|
|
self.np_x = np.random.rand(3, 2, 4).astype('float32')
|
|
self.np_y = np.random.rand(3, 4, 3).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.baddbmm(input, x, y, 1.0, 1.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.baddbmm(input=input, x=x, y=y, beta=1.0, alpha=1.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.baddbmm(
|
|
beta=1.0, alpha=1.0, input=input, batch1=x, batch2=y
|
|
)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.baddbmm(input, x, y, beta=1.0, alpha=1.0)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty_like(input)
|
|
out6 = paddle.baddbmm(input, x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = input.baddbmm(x, y, beta=1.0, alpha=1.0)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = input.baddbmm(batch1=x, batch2=y, beta=1.0, alpha=1.0)
|
|
ref_out = 1.0 * self.np_input + 1.0 * self.np_x @ self.np_y
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
|
|
# 2D input (1,1) broadcasts to result shape [3, 2, 3]
|
|
input_2d = paddle.to_tensor(np.array([[0.5]]).astype('float32'))
|
|
out8 = paddle.baddbmm(input_2d, x, y)
|
|
ref_out_2d = 0.5 + self.np_x @ self.np_y
|
|
np.testing.assert_allclose(ref_out_2d, out8.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
def test_error(self):
|
|
"""Test invalid input dimensions that should raise ValueError."""
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# Test 1D input (invalid)
|
|
input_1d = paddle.to_tensor(np.random.rand(3).astype('float32'))
|
|
with self.assertRaises(ValueError):
|
|
paddle.baddbmm(input_1d, x, y)
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
input = paddle.static.data(
|
|
name="input", shape=[3, 2, 3], dtype='float32'
|
|
)
|
|
x = paddle.static.data(name="x", shape=[3, 2, 4], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[3, 4, 3], dtype='float32')
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.baddbmm(input, x, y, 1.0, 1.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.baddbmm(input=input, x=x, y=y, beta=1.0, alpha=1.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.baddbmm(
|
|
beta=1, alpha=1, input=input, batch1=x, batch2=y
|
|
)
|
|
# 4. Tensor method - args
|
|
out4 = input.baddbmm(x, y, beta=1.0, alpha=1.0)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = input.baddbmm(batch1=x, batch2=y, beta=1.0, alpha=1.0)
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"input": self.np_input, "x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = 1.0 * self.np_input + 1.0 * self.np_x @ self.np_y
|
|
for out in fetches:
|
|
np.testing.assert_allclose(ref_out, out, rtol=1e-6)
|
|
|
|
|
|
# Test baddbmm_ API compatibility (paddle.baddbmm_ and paddle.Tensor.baddbmm_)
|
|
class TestBaddbmmInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3, 2, 3).astype('float32')
|
|
self.np_x = np.random.rand(3, 2, 4).astype('float32')
|
|
self.np_y = np.random.rand(3, 4, 3).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
out1 = paddle.baddbmm_(input.clone(), x, y, beta=0.5, alpha=0.7)
|
|
out2 = paddle.baddbmm_(
|
|
input=input.clone(), x=x, y=y, beta=0.5, alpha=0.7
|
|
)
|
|
out3 = paddle.baddbmm_(
|
|
input=input.clone(), batch1=x, batch2=y, beta=0.5, alpha=0.7
|
|
)
|
|
out4 = input.clone().baddbmm_(x, y, beta=0.5, alpha=0.7)
|
|
out5 = input.clone().baddbmm_(x=x, y=y, beta=0.5, alpha=0.7)
|
|
out6 = input.clone().baddbmm_(batch1=x, batch2=y, beta=0.5, alpha=0.7)
|
|
ref_out = 0.5 * self.np_input + 0.7 * self.np_x @ self.np_y
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test bitwise_left_shift compatibility
|
|
class TestBitwiseLeftShiftAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(1, 10, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(1, 5, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_left_shift(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_left_shift(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_left_shift(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bitwise_left_shift(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty([5, 6], dtype='int32')
|
|
out6 = paddle.bitwise_left_shift(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.bitwise_left_shift(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.bitwise_left_shift(other=y)
|
|
|
|
ref_out = np.left_shift(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_left_shift(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_left_shift(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_left_shift(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.bitwise_left_shift(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.bitwise_left_shift(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
ref_out = np.left_shift(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_left_shift_ inplace compatibility
|
|
class TestBitwiseLeftShiftInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(1, 10, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(1, 5, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.left_shift(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_left_shift_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().bitwise_left_shift_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().bitwise_left_shift_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.bitwise_left_shift_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.bitwise_left_shift_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.bitwise_left_shift_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
# Test bitwise_right_shift compatibility
|
|
class TestBitwiseRightShiftAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(10, 100, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(1, 5, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_right_shift(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_right_shift(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_right_shift(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.bitwise_right_shift(x, y=y)
|
|
# 5-6. out parameter test
|
|
out5 = paddle.empty([5, 6], dtype='int32')
|
|
out6 = paddle.bitwise_right_shift(x, y, out=out5)
|
|
# 7. Tensor method - args
|
|
out7 = x.bitwise_right_shift(y)
|
|
# 8. Tensor method - kwargs (PyTorch alias)
|
|
out8 = x.bitwise_right_shift(other=y)
|
|
|
|
ref_out = np.right_shift(self.np_x, self.np_y)
|
|
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='int32')
|
|
y = paddle.static.data(name="y", shape=[5, 6], dtype='int32')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.bitwise_right_shift(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.bitwise_right_shift(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.bitwise_right_shift(input=x, other=y)
|
|
# 4. Tensor method - args
|
|
out4 = x.bitwise_right_shift(y)
|
|
# 5. Tensor method - kwargs (PyTorch alias)
|
|
out5 = x.bitwise_right_shift(other=y)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "y": self.np_y},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
ref_out = np.right_shift(self.np_x, self.np_y)
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, ref_out)
|
|
|
|
|
|
# Test bitwise_right_shift_ inplace compatibility
|
|
class TestBitwiseRightShiftInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(10, 100, [5, 6]).astype('int32')
|
|
self.np_y = np.random.randint(1, 5, [5, 6]).astype('int32')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
y = paddle.to_tensor(self.np_y)
|
|
ref_out = np.right_shift(self.np_x, self.np_y)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone().bitwise_right_shift_(y)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone().bitwise_right_shift_(y=y)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone().bitwise_right_shift_(other=y)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.bitwise_right_shift_(x.clone(), y)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.bitwise_right_shift_(x=x.clone(), y=y)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.bitwise_right_shift_(input=x.clone(), other=y)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_array_equal(ref_out, out.numpy())
|
|
|
|
|
|
# Test cauchy_ inplace compatibility
|
|
class TestCauchyInplaceAPI(unittest.TestCase):
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
# 1. Tensor method - positional args
|
|
out1 = paddle.randn([3, 4], dtype='float32')
|
|
out1.cauchy_(1.0, 2.0)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = paddle.randn([3, 4], dtype='float32')
|
|
out2.cauchy_(loc=1.0, scale=2.0)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = paddle.randn([3, 4], dtype='float32')
|
|
out3.cauchy_(median=1.0, sigma=2.0)
|
|
# 4. Paddle function - positional args
|
|
out4 = paddle.randn([3, 4], dtype='float32')
|
|
paddle.cauchy_(out4, 1.0, 2.0)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = paddle.randn([3, 4], dtype='float32')
|
|
paddle.cauchy_(out5, loc=1.0, scale=2.0)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = paddle.randn([3, 4], dtype='float32')
|
|
paddle.cauchy_(out6, median=1.0, sigma=2.0)
|
|
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
self.assertEqual(out.shape, [3, 4])
|
|
|
|
|
|
class TestTensorCumsumInplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randint(1, 5, size=(3, 4)).astype('int64')
|
|
|
|
def test_dygraph_InplaceCompatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Tensor method - positional args
|
|
out1 = x.clone()
|
|
out1.cumsum_(1)
|
|
# 2. Tensor method - Paddle keyword args
|
|
out2 = x.clone()
|
|
out2.cumsum_(axis=1)
|
|
# 3. Tensor method - PyTorch keyword args (alias)
|
|
out3 = x.clone()
|
|
out3.cumsum_(dim=1)
|
|
# 4. Paddle function - positional args
|
|
out4 = x.clone()
|
|
paddle.cumsum_(out4, 1)
|
|
# 5. Paddle function - Paddle keyword args
|
|
out5 = x.clone()
|
|
paddle.cumsum_(out5, axis=1)
|
|
# 6. Paddle function - PyTorch keyword args (alias)
|
|
out6 = x.clone()
|
|
paddle.cumsum_(out6, dim=1)
|
|
|
|
ref = np.cumsum(self.np_x, axis=1)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref, out.numpy())
|
|
|
|
|
|
# Test real compatibility
|
|
class TestRealAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
np_x_real = np.random.randn(5, 6).astype('float32')
|
|
np_x_imag = np.random.randn(5, 6).astype('float32')
|
|
self.np_x = np_x_real + 1j * np_x_imag
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.real(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.real(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.real(input=x)
|
|
# 4-5. out parameter test
|
|
out4 = paddle.empty([5, 6], dtype='float32')
|
|
out5 = paddle.real(x, out=out4)
|
|
# 6. Tensor method
|
|
out6 = x.real()
|
|
|
|
# Verify all outputs
|
|
ref_out = np.real(self.np_x)
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-6)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[5, 6], dtype='complex64')
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = paddle.real(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.real(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.real(input=x)
|
|
# 4. Tensor method
|
|
out4 = x.real()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
ref_out = np.real(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(ref_out, out, rtol=1e-6)
|
|
|
|
|
|
# Test pixel_shuffle compatibility
|
|
class TestPixelShuffleAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.randn(2, 9, 4, 4).astype('float32')
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = F.pixel_shuffle(x, 3)
|
|
# 2. Paddle keyword arguments
|
|
out2 = F.pixel_shuffle(x=x, upscale_factor=3)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = F.pixel_shuffle(input=x, upscale_factor=3)
|
|
# 4. Mixed arguments
|
|
out4 = F.pixel_shuffle(x, upscale_factor=3)
|
|
|
|
# Verify all outputs match
|
|
for out in [out2, out3, out4]:
|
|
np.testing.assert_array_equal(out1.numpy(), out.numpy())
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=[2, 9, 4, 4], dtype='float32'
|
|
)
|
|
|
|
# 1. Paddle positional arguments
|
|
out1 = F.pixel_shuffle(x, 3)
|
|
# 2. Paddle keyword arguments
|
|
out2 = F.pixel_shuffle(x=x, upscale_factor=3)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = F.pixel_shuffle(input=x, upscale_factor=3)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
for out in fetches[1:]:
|
|
np.testing.assert_array_equal(fetches[0], out)
|
|
|
|
|
|
# Test paddle.set_rng_state compatibility
|
|
class TestSetRngStateAPI(unittest.TestCase):
|
|
def test_Compatibility(self):
|
|
states = paddle.get_rng_state()
|
|
# 1. positional argument
|
|
paddle.set_rng_state(states)
|
|
# 2. paddle-style keyword argument
|
|
paddle.set_rng_state(state_list=states)
|
|
# 3. torch-style keyword argument
|
|
paddle.set_rng_state(new_state=states)
|
|
|
|
|
|
class _CompatBatchNormBase:
|
|
api = None
|
|
alias = None
|
|
alias_name = None
|
|
original_api = None
|
|
x_shape = None
|
|
invalid_shape = None
|
|
axes = None
|
|
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.num_features = 3
|
|
self.eps = 1e-5
|
|
self.np_x = np.random.rand(*self.x_shape).astype("float32") * 2 - 1
|
|
self.np_x_alt = np.random.rand(*self.x_shape).astype("float32") * 2 - 1
|
|
|
|
def _expected(self, x=None, eps=None):
|
|
x = self.np_x if x is None else x
|
|
eps = self.eps if eps is None else eps
|
|
mean = np.mean(x, axis=self.axes, keepdims=True)
|
|
var = np.var(x, axis=self.axes, keepdims=True)
|
|
return (x - mean) / np.sqrt(var + eps)
|
|
|
|
def _check_outputs(self, outputs, expected=None, rtol=1e-5):
|
|
expected = self._expected() if expected is None else expected
|
|
for out in outputs:
|
|
np.testing.assert_allclose(out.numpy(), expected, rtol=rtol)
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle positional arguments
|
|
layer1 = self.alias(self.num_features)
|
|
out1 = layer1(x)
|
|
# 2. Paddle keyword arguments
|
|
layer2 = self.alias(num_features=self.num_features, eps=self.eps)
|
|
out2 = layer2(x)
|
|
# 3. PyTorch positional arguments
|
|
layer3 = self.alias(
|
|
self.num_features, self.eps, 0.2, False, False, None, "float64"
|
|
)
|
|
x64 = paddle.to_tensor(self.np_x.astype("float64"))
|
|
out3 = layer3(x64)
|
|
# 4. PyTorch keyword arguments
|
|
layer4 = self.alias(
|
|
dtype="float32",
|
|
device=None,
|
|
track_running_stats=True,
|
|
affine=True,
|
|
momentum=0.2,
|
|
eps=self.eps,
|
|
num_features=self.num_features,
|
|
)
|
|
out4 = layer4(x)
|
|
# 5. Mixed arguments
|
|
layer5 = self.alias(self.num_features, eps=self.eps)
|
|
out5 = layer5(x)
|
|
|
|
self._check_outputs([out1, out2, out4, out5])
|
|
np.testing.assert_allclose(
|
|
out3.numpy(),
|
|
self._expected(self.np_x.astype("float64")),
|
|
rtol=1e-5,
|
|
)
|
|
self.assertEqual(layer4._momentum, 0.8)
|
|
self.assertIsNone(layer4._use_global_stats)
|
|
self.assertIs(self.api, self.alias)
|
|
|
|
layer6 = self.alias(self.num_features, track_running_stats=False)
|
|
layer6.eval()
|
|
out6 = layer6(x)
|
|
self.assertFalse(layer6._use_global_stats)
|
|
self._check_outputs([out6])
|
|
|
|
layer7 = self.alias(self.num_features, momentum=None)
|
|
out7 = layer7(x)
|
|
self._check_outputs([out7])
|
|
self.assertIsNone(layer7.momentum)
|
|
self.assertEqual(layer7._num_batches_tracked, 1)
|
|
self.assertIsNone(layer7._momentum)
|
|
layer7(paddle.to_tensor(self.np_x_alt))
|
|
self.assertEqual(layer7._num_batches_tracked, 2)
|
|
self.assertIsNone(layer7._momentum)
|
|
|
|
layer8 = self.alias(self.num_features)
|
|
layer8.eval()
|
|
out8 = layer8(x)
|
|
np.testing.assert_allclose(
|
|
out8.numpy(),
|
|
self.np_x / np.sqrt(1.0 + self.eps),
|
|
rtol=1e-5,
|
|
)
|
|
|
|
bad_x = paddle.ones(self.invalid_shape, dtype="float32")
|
|
with self.assertRaises(ValueError):
|
|
layer1(bad_x)
|
|
|
|
original_layer = self.original_api(self.num_features)
|
|
original_layer(x)
|
|
self.assertEqual(original_layer._momentum, 0.9)
|
|
original_none = self.original_api(self.num_features, momentum=None)
|
|
original_none(x)
|
|
self.assertEqual(original_none._num_batches_tracked, 1)
|
|
self.assertIsNone(original_none._momentum)
|
|
original_none(paddle.to_tensor(self.np_x_alt))
|
|
self.assertEqual(original_none._num_batches_tracked, 2)
|
|
self.assertIsNone(original_none._momentum)
|
|
original_eps = self.original_api(self.num_features, eps=self.eps)
|
|
self.assertEqual(original_eps._epsilon, self.eps)
|
|
original_affine = self.original_api(self.num_features, affine=False)
|
|
self.assertIsNone(original_affine.weight)
|
|
self.assertIsNone(original_affine.bias)
|
|
original_dtype = self.original_api(self.num_features, dtype="float64")
|
|
self.assertEqual(original_dtype._dtype, "float64")
|
|
self.assertFalse(hasattr(paddle.nn, self.alias_name))
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=self.x_shape, dtype=str(self.np_x.dtype)
|
|
)
|
|
|
|
# 1. Paddle positional arguments
|
|
layer1 = self.alias(self.num_features)
|
|
out1 = layer1(x)
|
|
# 2. Paddle keyword arguments
|
|
layer2 = self.alias(num_features=self.num_features, eps=self.eps)
|
|
out2 = layer2(x)
|
|
# 3. PyTorch positional arguments
|
|
layer3 = self.alias(
|
|
self.num_features, self.eps, 0.2, False, False, None, "float32"
|
|
)
|
|
out3 = layer3(x)
|
|
# 4. PyTorch keyword arguments
|
|
layer4 = self.alias(
|
|
dtype="float32",
|
|
device=None,
|
|
track_running_stats=False,
|
|
affine=True,
|
|
momentum=0.2,
|
|
eps=self.eps,
|
|
num_features=self.num_features,
|
|
)
|
|
out4 = layer4(x)
|
|
# 5. Mixed arguments
|
|
layer5 = self.alias(self.num_features, momentum=None)
|
|
out5 = layer5(x)
|
|
|
|
self.assertFalse(layer4._use_global_stats)
|
|
self.assertEqual(layer4._momentum, 0.8)
|
|
self.assertIsNone(layer5._momentum)
|
|
|
|
exe = paddle.static.Executor()
|
|
exe.run(startup)
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4, out5],
|
|
)
|
|
|
|
expected = self._expected()
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, expected, rtol=1e-5)
|
|
|
|
|
|
class TestCompatBatchNorm1dAPI(_CompatBatchNormBase, unittest.TestCase):
|
|
api = paddle.compat.nn.BatchNorm1D
|
|
alias = paddle.compat.nn.BatchNorm1d
|
|
alias_name = "BatchNorm1d"
|
|
original_api = paddle.nn.BatchNorm1D
|
|
x_shape = (4, 3, 5)
|
|
invalid_shape = (2, 3, 4, 5)
|
|
axes = (0, 2)
|
|
|
|
def test_dygraph_2DInput(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.rand(4, self.num_features).astype("float32") * 2 - 1
|
|
x = paddle.to_tensor(x_np)
|
|
out = self.alias(self.num_features)(x)
|
|
expected = (x_np - np.mean(x_np, axis=0)) / np.sqrt(
|
|
np.var(x_np, axis=0) + self.eps
|
|
)
|
|
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-5)
|
|
paddle.enable_static()
|
|
|
|
|
|
class TestCompatBatchNorm2dAPI(_CompatBatchNormBase, unittest.TestCase):
|
|
api = paddle.compat.nn.BatchNorm2D
|
|
alias = paddle.compat.nn.BatchNorm2d
|
|
alias_name = "BatchNorm2d"
|
|
original_api = paddle.nn.BatchNorm2D
|
|
x_shape = (2, 3, 4, 5)
|
|
invalid_shape = (2, 3, 4)
|
|
axes = (0, 2, 3)
|
|
|
|
|
|
class TestCompatBatchNorm3dAPI(_CompatBatchNormBase, unittest.TestCase):
|
|
api = paddle.compat.nn.BatchNorm3D
|
|
alias = paddle.compat.nn.BatchNorm3d
|
|
alias_name = "BatchNorm3d"
|
|
original_api = paddle.nn.BatchNorm3D
|
|
x_shape = (2, 3, 2, 4, 5)
|
|
invalid_shape = (2, 3, 4, 5)
|
|
axes = (0, 2, 3, 4)
|
|
|
|
|
|
# Test DistributedSampler compatibility
|
|
class TestDistributedSamplerAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
|
|
class SimpleDataset:
|
|
def __init__(self, size):
|
|
self.size = size
|
|
|
|
def __getitem__(self, idx):
|
|
x = idx
|
|
y = 2 * idx
|
|
return x, y
|
|
|
|
def __len__(self):
|
|
return self.size
|
|
|
|
self.dataset = SimpleDataset(100)
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
"""Test DistributedSampler as alias for DistributedBatchSampler"""
|
|
# 1. positional arguments
|
|
sampler1 = paddle.utils.data.DistributedSampler(
|
|
self.dataset, 2, 0, False, 2026, False
|
|
)
|
|
# 2. keyword arguments
|
|
sampler2 = paddle.utils.data.DistributedSampler(
|
|
dataset=self.dataset,
|
|
num_replicas=2,
|
|
rank=0,
|
|
shuffle=False,
|
|
seed=2026,
|
|
drop_last=False,
|
|
)
|
|
# Verify both samplers produce same batches
|
|
batches1 = list(sampler1)
|
|
batches2 = list(sampler2)
|
|
self.assertEqual(len(batches1), len(batches2))
|
|
for b1, b2 in zip(batches1, batches2):
|
|
self.assertEqual(b1, b2)
|
|
|
|
def test_set_epoch(self):
|
|
"""Test set_epoch method"""
|
|
sampler = paddle.utils.data.DistributedSampler(
|
|
self.dataset, num_replicas=2, rank=0, shuffle=True
|
|
)
|
|
# Collect samples from epoch 0
|
|
sampler.set_epoch(0)
|
|
batches0 = list(sampler)
|
|
# Collect samples from epoch 1
|
|
sampler.set_epoch(1)
|
|
batches1 = list(sampler)
|
|
self.assertEqual(len(batches0), len(batches1))
|
|
|
|
|
|
# Edit By AI Agent
|
|
# Test expand_copy compatibility
|
|
class TestExpandCopyAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
paddle.disable_static()
|
|
self.x = paddle.to_tensor([1, 2, 3], dtype='int32')
|
|
|
|
def test_dygraph(self):
|
|
paddle.disable_static()
|
|
# Test 1: positional arguments
|
|
out1 = paddle.expand_copy(self.x, shape=[2, 3])
|
|
self.assertEqual(out1.shape, [2, 3])
|
|
|
|
# Test 2: keyword arguments (PyTorch alias)
|
|
out2 = paddle.expand_copy(x=self.x, shape=[2, 3])
|
|
self.assertEqual(out2.shape, [2, 3])
|
|
|
|
# Test 3: Tensor method
|
|
out3 = self.x.expand_copy(shape=[2, 3])
|
|
self.assertEqual(out3.shape, [2, 3])
|
|
|
|
# Test 4: expand_copy with -1 (keep dim)
|
|
out4 = paddle.expand_copy(self.x, shape=[2, -1])
|
|
self.assertEqual(out4.shape, [2, 3])
|
|
|
|
# Test 5: expand_copy with same shape (no-op)
|
|
out5 = paddle.expand_copy(self.x, shape=[3])
|
|
self.assertEqual(out5.shape, [3])
|
|
|
|
# Verify that result equals expand
|
|
ref = paddle.expand(self.x, shape=[2, 3])
|
|
self.assertTrue(paddle.equal_all(out1, ref))
|
|
|
|
# Verify stop_gradient
|
|
x = paddle.to_tensor([1.0, 2.0, 3.0], stop_gradient=False)
|
|
out = paddle.expand_copy(x, shape=[2, 3])
|
|
self.assertFalse(out.stop_gradient)
|
|
|
|
# Test 6: expand_decorator alias: input -> x
|
|
out6 = paddle.expand_copy(input=self.x, shape=[2, 3])
|
|
self.assertEqual(out6.shape, [2, 3])
|
|
self.assertTrue(paddle.equal_all(out1, out6))
|
|
|
|
# Test 7: expand_decorator alias: size -> shape
|
|
out7 = paddle.expand_copy(self.x, size=[2, 3])
|
|
self.assertEqual(out7.shape, [2, 3])
|
|
self.assertTrue(paddle.equal_all(out1, out7))
|
|
|
|
# Test 8: expand_decorator alias: both input and size aliases
|
|
out8 = paddle.expand_copy(input=self.x, size=[2, 3])
|
|
self.assertEqual(out8.shape, [2, 3])
|
|
self.assertTrue(paddle.equal_all(out1, out8))
|
|
|
|
# Test 9: expand_decorator variable positional int args
|
|
out9 = paddle.expand_copy(self.x, 2, 3)
|
|
self.assertEqual(out9.shape, [2, 3])
|
|
self.assertTrue(paddle.equal_all(out1, out9))
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=[3], dtype="int32")
|
|
|
|
out1 = paddle.expand_copy(x, shape=[2, 3])
|
|
out2 = paddle.expand_copy(input=x, shape=[2, 3])
|
|
out3 = paddle.expand_copy(x, size=[2, 3])
|
|
|
|
exe = paddle.static.Executor()
|
|
np_x = np.array([1, 2, 3]).astype("int32")
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": np_x},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
expected = np.broadcast_to(np_x, (2, 3))
|
|
for out in fetches:
|
|
np.testing.assert_array_equal(out, expected)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|