wehub-resource-sync
3231 lines
116 KiB
Python
3231 lines
116 KiB
Python
# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
|
||
#
|
||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||
# you may not use this file except in compliance with the License.
|
||
# You may obtain a copy of the License at
|
||
#
|
||
# http://www.apache.org/licenses/LICENSE-2.0
|
||
#
|
||
# Unless required by applicable law or agreed to in writing, software
|
||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
# See the License for the specific language governing permissions and
|
||
# limitations under the License.
|
||
|
||
import unittest
|
||
|
||
import numpy as np
|
||
|
||
import paddle
|
||
|
||
|
||
# Test flex_attention mask helpers compatibility
|
||
class TestFlexAttentionMasksAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_b = np.array([[0, 1, 0], [1, 0, 1]], dtype='int64')
|
||
self.np_h = np.array([[0, 1, 1], [0, 0, 1]], dtype='int64')
|
||
self.np_q_idx = np.array([[0, 2, 4], [3, 5, 7]], dtype='int64')
|
||
self.np_kv_idx = np.array([[1, 2, 3], [4, 4, 8]], dtype='int64')
|
||
self.ref_ge = self.np_q_idx >= self.np_kv_idx
|
||
self.ref_h_zero = self.np_h == 0
|
||
|
||
def mask_q_ge_kv(self, b, h, q_idx, kv_idx):
|
||
return q_idx >= kv_idx
|
||
|
||
def mask_h_zero(self, b, h, q_idx, kv_idx):
|
||
return h == 0
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
b = paddle.to_tensor(self.np_b)
|
||
h = paddle.to_tensor(self.np_h)
|
||
q_idx = paddle.to_tensor(self.np_q_idx)
|
||
kv_idx = paddle.to_tensor(self.np_kv_idx)
|
||
|
||
# 1. PyTorch positional arguments
|
||
out1 = paddle.nn.attention.flex_attention.or_masks(
|
||
self.mask_q_ge_kv, self.mask_h_zero
|
||
)(b, h, q_idx, kv_idx)
|
||
out2 = paddle.nn.attention.flex_attention.and_masks(
|
||
self.mask_q_ge_kv, self.mask_h_zero
|
||
)(b, h, q_idx, kv_idx)
|
||
out3 = paddle.nn.attention.flex_attention.or_masks(self.mask_q_ge_kv)(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
out4 = paddle.nn.attention.flex_attention.and_masks(self.mask_h_zero)(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
out5 = paddle.nn.attention.flex_attention.or_masks()(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
out6 = paddle.nn.attention.flex_attention.and_masks()(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
|
||
refs = [
|
||
np.logical_or(self.ref_ge, self.ref_h_zero),
|
||
np.logical_and(self.ref_ge, self.ref_h_zero),
|
||
self.ref_ge,
|
||
self.ref_h_zero,
|
||
np.array(False),
|
||
np.array(True),
|
||
]
|
||
for out, ref in zip([out1, out2, out3, out4, out5, out6], refs):
|
||
np.testing.assert_array_equal(out.numpy(), ref)
|
||
|
||
with self.assertRaises(RuntimeError):
|
||
paddle.nn.attention.flex_attention.or_masks(self.mask_q_ge_kv, 1)
|
||
with self.assertRaises(RuntimeError):
|
||
paddle.nn.attention.flex_attention.and_masks(1, self.mask_h_zero)
|
||
|
||
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):
|
||
b = paddle.static.data(name="b", shape=[2, 3], dtype='int64')
|
||
h = paddle.static.data(name="h", shape=[2, 3], dtype='int64')
|
||
q_idx = paddle.static.data(
|
||
name="q_idx", shape=[2, 3], dtype='int64'
|
||
)
|
||
kv_idx = paddle.static.data(
|
||
name="kv_idx", shape=[2, 3], dtype='int64'
|
||
)
|
||
|
||
# 1. PyTorch positional arguments
|
||
out1 = paddle.nn.attention.flex_attention.or_masks(
|
||
self.mask_q_ge_kv, self.mask_h_zero
|
||
)(b, h, q_idx, kv_idx)
|
||
out2 = paddle.nn.attention.flex_attention.and_masks(
|
||
self.mask_q_ge_kv, self.mask_h_zero
|
||
)(b, h, q_idx, kv_idx)
|
||
out3 = paddle.nn.attention.flex_attention.or_masks(
|
||
self.mask_q_ge_kv
|
||
)(b, h, q_idx, kv_idx)
|
||
out4 = paddle.nn.attention.flex_attention.and_masks(
|
||
self.mask_h_zero
|
||
)(b, h, q_idx, kv_idx)
|
||
out5 = paddle.nn.attention.flex_attention.or_masks()(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
out6 = paddle.nn.attention.flex_attention.and_masks()(
|
||
b, h, q_idx, kv_idx
|
||
)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={
|
||
"b": self.np_b,
|
||
"h": self.np_h,
|
||
"q_idx": self.np_q_idx,
|
||
"kv_idx": self.np_kv_idx,
|
||
},
|
||
fetch_list=[out1, out2, out3, out4, out5, out6],
|
||
)
|
||
|
||
refs = [
|
||
np.logical_or(self.ref_ge, self.ref_h_zero),
|
||
np.logical_and(self.ref_ge, self.ref_h_zero),
|
||
self.ref_ge,
|
||
self.ref_h_zero,
|
||
np.array(False),
|
||
np.array(True),
|
||
]
|
||
for out, ref in zip(fetches, refs):
|
||
np.testing.assert_array_equal(out, ref)
|
||
|
||
|
||
# Test block_diag compatibility
|
||
class TestBlockDiagAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(2, 3).astype('float32')
|
||
self.np_y = np.random.rand(3, 4).astype('float32')
|
||
self.np_z = np.random.rand(1, 2).astype('float32')
|
||
|
||
def _ref_block_diag(self, *arrays):
|
||
import scipy.linalg
|
||
|
||
return scipy.linalg.block_diag(*arrays)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
y = paddle.to_tensor(self.np_y)
|
||
z = paddle.to_tensor(self.np_z)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.block_diag([x, y, z])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.block_diag(inputs=[x, y, z])
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.block_diag(x, y, z)
|
||
|
||
ref_out = self._ref_block_diag(self.np_x, self.np_y, self.np_z)
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(ref_out, out.numpy(), rtol=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=[2, 3], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[3, 4], dtype='float32')
|
||
z = paddle.static.data(name="z", shape=[1, 2], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.block_diag([x, y, z])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.block_diag(inputs=[x, y, z])
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.block_diag(x, y, z)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y, "z": self.np_z},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
ref_out = self._ref_block_diag(self.np_x, self.np_y, self.np_z)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test broadcast_tensors compatibility
|
||
class TestBroadcastTensorsAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 1).astype('float32')
|
||
self.np_y = np.random.rand(1, 4).astype('float32')
|
||
self.np_z = np.random.rand(3, 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)
|
||
z = paddle.to_tensor(self.np_z)
|
||
|
||
# 1. Paddle positional arguments
|
||
outs1 = paddle.broadcast_tensors([x, y, z])
|
||
# 2. Paddle keyword arguments
|
||
outs2 = paddle.broadcast_tensors(input=[x, y, z])
|
||
# 3. PyTorch positional arguments
|
||
outs3 = paddle.broadcast_tensors(x, y, z)
|
||
|
||
# Verify all outputs
|
||
ref_x = np.broadcast_to(self.np_x, [3, 4])
|
||
ref_y = np.broadcast_to(self.np_y, [3, 4])
|
||
ref_z = np.broadcast_to(self.np_z, [3, 4])
|
||
|
||
refs = [ref_x, ref_y, ref_z]
|
||
for outs in [outs1, outs2, outs3]:
|
||
self.assertEqual(len(outs), 3)
|
||
for i, ref in enumerate(refs):
|
||
np.testing.assert_allclose(ref, outs[i].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, 1], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[1, 4], dtype='float32')
|
||
z = paddle.static.data(name="z", shape=[3, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
outs1 = paddle.broadcast_tensors([x, y, z])
|
||
# 2. Paddle keyword arguments
|
||
outs2 = paddle.broadcast_tensors(input=[x, y, z])
|
||
# 3. PyTorch positional arguments
|
||
outs3 = paddle.broadcast_tensors(x, y, z)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y, "z": self.np_z},
|
||
fetch_list=[
|
||
outs1[0],
|
||
outs1[1],
|
||
outs1[2],
|
||
outs2[0],
|
||
outs2[1],
|
||
outs2[2],
|
||
outs3[0],
|
||
outs3[1],
|
||
outs3[2],
|
||
],
|
||
)
|
||
|
||
ref_x = np.broadcast_to(self.np_x, [3, 4])
|
||
ref_y = np.broadcast_to(self.np_y, [3, 4])
|
||
ref_z = np.broadcast_to(self.np_z, [3, 4])
|
||
|
||
refs = [ref_x, ref_y, ref_z] * 3
|
||
for i, ref in enumerate(refs):
|
||
np.testing.assert_allclose(fetches[i], ref)
|
||
|
||
|
||
# Test cartesian_prod compatibility
|
||
class TestCartesianProdAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([1, 2, 3], dtype='int64')
|
||
self.np_y = np.array([4, 5, 6, 7], dtype='int64')
|
||
|
||
def compute_ref_output(self):
|
||
# Compute cartesian product
|
||
x_grid, y_grid = np.meshgrid(self.np_x, self.np_y, indexing='ij')
|
||
return np.stack([x_grid.ravel(), y_grid.ravel()], axis=-1)
|
||
|
||
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.cartesian_prod([x, y])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cartesian_prod(x=[x, y])
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.cartesian_prod(x, y)
|
||
|
||
# Verify outputs
|
||
ref_out = self.compute_ref_output()
|
||
for out in [out1, out2, out3]:
|
||
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=[3], dtype='int64')
|
||
y = paddle.static.data(name="y", shape=[4], dtype='int64')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.cartesian_prod([x, y])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cartesian_prod(x=[x, y])
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.cartesian_prod(x, y)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
ref_out = self.compute_ref_output()
|
||
for out in fetches:
|
||
np.testing.assert_array_equal(out, ref_out)
|
||
|
||
|
||
# Test copysign compatibility
|
||
class TestCopysignAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.randn(3, 4).astype('float32')
|
||
self.np_y = np.random.randn(3, 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)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.copysign(x, y)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.copysign(x=x, y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.copysign(input=x, other=y)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.copysign(x, other=y)
|
||
# 5-6. out parameter test
|
||
out5 = paddle.empty_like(x)
|
||
out6 = paddle.copysign(x, y, out=out5)
|
||
# 7. Class method positional arguments
|
||
out7 = x.copysign(y)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.copysign(y=y)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.copysign(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-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=[3, 4], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[3, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.copysign(x, y)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.copysign(x=x, y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.copysign(input=x, other=y)
|
||
# 4. Class method positional arguments
|
||
out4 = x.copysign(y)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.copysign(y=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.copysign(self.np_x, self.np_y)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test Tensor.copysign_ inplace compatibility
|
||
class TestTensorCopysignInplaceAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.randn(3, 4).astype('float32')
|
||
self.np_y = np.random.randn(3, 4).astype('float32')
|
||
|
||
def test_dygraph_inplace_Compatibility(self):
|
||
paddle.disable_static()
|
||
y = paddle.to_tensor(self.np_y)
|
||
ref_out = np.copysign(self.np_x, self.np_y)
|
||
|
||
# 1. Class method positional arguments
|
||
out1 = paddle.to_tensor(self.np_x)
|
||
out1.copysign_(y)
|
||
# 2. Class method keyword arguments
|
||
out2 = paddle.to_tensor(self.np_x)
|
||
out2.copysign_(y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.to_tensor(self.np_x)
|
||
out3.copysign_(other=y)
|
||
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-5)
|
||
|
||
paddle.enable_static()
|
||
|
||
|
||
# Test Tensor.geometric_ inplace compatibility
|
||
class TestTensorGeometricInplaceAPI(unittest.TestCase):
|
||
def test_dygraph_inplace_Compatibility(self):
|
||
paddle.disable_static()
|
||
|
||
# 1. Class method positional arguments
|
||
out1 = paddle.empty([10000], dtype='float32')
|
||
out1.geometric_(0.3)
|
||
# 2. Class method keyword arguments
|
||
out2 = paddle.empty([10000], dtype='float32')
|
||
out2.geometric_(p=0.3)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.empty([10000], dtype='float32')
|
||
out3.geometric_(probs=0.3)
|
||
|
||
for out in [out1, out2, out3]:
|
||
self.assertEqual(out.shape, [10000])
|
||
self.assertTrue((out.numpy() > 0).all())
|
||
|
||
paddle.enable_static()
|
||
|
||
|
||
# Test Tensor.hypot_ inplace compatibility
|
||
class TestTensorHypotInplaceAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 4).astype('float32') + 1.0
|
||
self.np_y = np.random.rand(3, 4).astype('float32') + 1.0
|
||
|
||
def test_dygraph_inplace_Compatibility(self):
|
||
paddle.disable_static()
|
||
y = paddle.to_tensor(self.np_y)
|
||
ref_out = np.hypot(self.np_x, self.np_y)
|
||
|
||
# 1. Class method positional arguments
|
||
out1 = paddle.to_tensor(self.np_x)
|
||
out1.hypot_(y)
|
||
# 2. Class method keyword arguments
|
||
out2 = paddle.to_tensor(self.np_x)
|
||
out2.hypot_(y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.to_tensor(self.np_x)
|
||
out3.hypot_(other=y)
|
||
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-5)
|
||
|
||
paddle.enable_static()
|
||
|
||
|
||
# Test index_fill compatibility
|
||
class TestIndexFillAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(5, 6).astype('float32')
|
||
self.np_index = np.array([1, 3, 4], dtype='int64')
|
||
|
||
def compute_ref_output(self):
|
||
ref = self.np_x.copy()
|
||
ref[:, self.np_index] = -1.0
|
||
return ref
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
index = paddle.to_tensor(self.np_index)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.index_fill(x, index, 1, -1.0)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.index_fill(x=x, index=index, axis=1, value=-1.0)
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.index_fill(x, 1, index, -1.0)
|
||
# 4. PyTorch keyword arguments
|
||
out4 = paddle.index_fill(input=x, dim=1, index=index, value=-1.0)
|
||
# 5. Mixed arguments
|
||
out5 = paddle.index_fill(x, index, axis=1, value=-1.0)
|
||
# 6. Class method positional arguments
|
||
out6 = x.index_fill(index, 1, -1.0)
|
||
# 7. Class method keyword arguments
|
||
out7 = x.index_fill(index=index, axis=1, value=-1.0)
|
||
|
||
# Verify all outputs
|
||
ref_out = self.compute_ref_output()
|
||
for out in [out1, out2, out3, out4, out5, out6, out7]:
|
||
np.testing.assert_allclose(ref_out, out.numpy(), rtol=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='float32')
|
||
index = paddle.static.data(name="index", shape=[3], dtype='int64')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.index_fill(x, index, 1, -1.0)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.index_fill(x=x, index=index, axis=1, value=-1.0)
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.index_fill(x, 1, index, -1.0)
|
||
# 4. PyTorch keyword arguments
|
||
out4 = paddle.index_fill(input=x, dim=1, index=index, value=-1.0)
|
||
# 5. Class method positional arguments
|
||
out5 = x.index_fill(index, 1, -1.0)
|
||
# 6. Class method keyword arguments
|
||
out6 = x.index_fill(index=index, axis=1, value=-1.0)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "index": self.np_index},
|
||
fetch_list=[out1, out2, out3, out4, out5, out6],
|
||
)
|
||
|
||
ref_out = self.compute_ref_output()
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
@unittest.skipIf(
|
||
paddle.is_compiled_with_xpu(),
|
||
"skip xpu which not support index_fill_ (which use stride)",
|
||
)
|
||
# Test Tensor.index_fill_ inplace compatibility
|
||
class TestTensorIndexFillInplaceAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(5, 6).astype('float32')
|
||
self.np_index = np.array([1, 3, 4], dtype='int64')
|
||
|
||
def compute_ref_output(self):
|
||
ref = self.np_x.copy()
|
||
ref[:, self.np_index] = -1.0
|
||
return ref
|
||
|
||
def test_dygraph_inplace_Compatibility(self):
|
||
paddle.disable_static()
|
||
index = paddle.to_tensor(self.np_index)
|
||
ref_out = self.compute_ref_output()
|
||
|
||
# 1. Class method positional arguments
|
||
out1 = paddle.to_tensor(self.np_x)
|
||
out1.index_fill_(index, 1, -1.0)
|
||
# 2. Class method keyword arguments
|
||
out2 = paddle.to_tensor(self.np_x)
|
||
out2.index_fill_(index=index, axis=1, value=-1.0)
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.to_tensor(self.np_x)
|
||
out3.index_fill_(1, index, -1.0)
|
||
# 4. PyTorch keyword arguments
|
||
out4 = paddle.to_tensor(self.np_x)
|
||
out4.index_fill_(dim=1, index=index, value=-1.0)
|
||
# 5. Mixed arguments
|
||
out5 = paddle.to_tensor(self.np_x)
|
||
out5.index_fill_(index, axis=1, value=-1.0)
|
||
|
||
for out in [out1, out2, out3, out4, out5]:
|
||
np.testing.assert_allclose(ref_out, out.numpy(), rtol=1e-5)
|
||
|
||
|
||
# Test cross compatibility
|
||
class TestCrossAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 3, 3).astype('float32')
|
||
self.np_y = np.random.rand(3, 3, 3).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 (all positional: x, y, axis）
|
||
out1 = paddle.cross(x, y, 1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.cross(x=x, y=y, axis=1)
|
||
# 3. PyTorch keyword arguments (using aliases input, other, dim)
|
||
out3 = paddle.cross(input=x, other=y, dim=1)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.cross(x, y=y, axis=1)
|
||
# 5. Class method positional arguments
|
||
out5 = x.cross(y, 1)
|
||
# 6. Class method keyword arguments
|
||
out6 = x.cross(y=y, axis=1)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.cross(self.np_x, self.np_y, axisa=1, axisb=1, axisc=1)
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=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=[3, 3, 3], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[3, 3, 3], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: x, y, axis）
|
||
out1 = paddle.cross(x, y, 1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.cross(x=x, y=y, axis=1)
|
||
# 3. PyTorch keyword arguments (using aliases input, other, dim)
|
||
out3 = paddle.cross(input=x, other=y, dim=1)
|
||
# 4. Class method positional arguments
|
||
out4 = x.cross(y, 1)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.cross(y=y, axis=1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.cross(self.np_x, self.np_y, axisa=1, axisb=1, axisc=1)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
class TestLinalgCrossAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
# Shape [3, 2, 3] ensures default dim=-1 (last dim=2) is distinct from auto-axis (first len-3 dim=0)
|
||
# Both dim 0 and dim 2 have size 3, so cross is valid on both
|
||
self.np_x = np.random.rand(3, 2, 3).astype('float32')
|
||
self.np_y = np.random.rand(3, 2, 3).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. linalg.cross with default dim=-1
|
||
out1 = paddle.linalg.cross(x, y)
|
||
# 2. linalg.cross with explicit dim=-1
|
||
out2 = paddle.linalg.cross(x, y, dim=-1)
|
||
# 3. linalg.cross using input/other/dim PyTorch-style keywords, dim=2
|
||
out3 = paddle.linalg.cross(input=x, other=y, dim=2)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.linalg.cross(x, other=y, dim=0)
|
||
|
||
# Verify default is equivalent to dim=-1
|
||
ref_out_neg1 = np.cross(
|
||
self.np_x, self.np_y, axisa=-1, axisb=-1, axisc=-1
|
||
)
|
||
np.testing.assert_allclose(out1.numpy(), ref_out_neg1, rtol=1e-5)
|
||
np.testing.assert_allclose(out2.numpy(), ref_out_neg1, rtol=1e-5)
|
||
|
||
# Verify dim=2 is same as dim=-1 (last dim)
|
||
np.testing.assert_allclose(out3.numpy(), ref_out_neg1, rtol=1e-5)
|
||
|
||
# Verify dim=0 gives different result
|
||
ref_out_0 = np.cross(self.np_x, self.np_y, axisa=0, axisb=0, axisc=0)
|
||
np.testing.assert_allclose(out4.numpy(), ref_out_0, rtol=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=[3, 2, 3], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[3, 2, 3], dtype='float32')
|
||
|
||
# 1. linalg.cross with default dim=-1
|
||
out1 = paddle.linalg.cross(x, y)
|
||
# 2. linalg.cross with explicit dim=0
|
||
out2 = paddle.linalg.cross(x, y, dim=0)
|
||
# 3. linalg.cross using input/other/dim keywords with dim=2
|
||
out3 = paddle.linalg.cross(input=x, other=y, dim=2)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
# Verify default is equivalent to dim=-1
|
||
ref_out_neg1 = np.cross(
|
||
self.np_x, self.np_y, axisa=-1, axisb=-1, axisc=-1
|
||
)
|
||
np.testing.assert_allclose(fetches[0], ref_out_neg1, rtol=1e-5)
|
||
|
||
# Verify dim=0
|
||
ref_out_0 = np.cross(
|
||
self.np_x, self.np_y, axisa=0, axisb=0, axisc=0
|
||
)
|
||
np.testing.assert_allclose(fetches[1], ref_out_0, rtol=1e-5)
|
||
|
||
# Verify dim=2
|
||
ref_out_2 = np.cross(
|
||
self.np_x, self.np_y, axisa=2, axisb=2, axisc=2
|
||
)
|
||
np.testing.assert_allclose(fetches[2], ref_out_2, rtol=1e-5)
|
||
|
||
|
||
# Test dist compatibility
|
||
class TestDistAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(2, 2).astype('float32')
|
||
self.np_y = np.random.rand(2, 2).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 (all positional: x, y, p）
|
||
out1 = paddle.dist(x, y, 2.0)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.dist(x=x, y=y, p=2.0)
|
||
# 3. PyTorch keyword arguments (using aliases input and other)
|
||
out3 = paddle.dist(input=x, other=y, p=2.0)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.dist(x, y, p=2.0)
|
||
# 5. Class method positional arguments
|
||
out5 = x.dist(y, 2.0)
|
||
# 6. Class method keyword arguments
|
||
out6 = x.dist(y=y, p=2.0)
|
||
|
||
# Verify all outputs
|
||
ref_out = float(np.linalg.norm((self.np_x - self.np_y).flatten()))
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=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=[2, 2], dtype='float32')
|
||
y = paddle.static.data(name="y", shape=[2, 2], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: x, y, p）
|
||
out1 = paddle.dist(x, y, 2.0)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.dist(x=x, y=y, p=2.0)
|
||
# 3. PyTorch keyword arguments (using aliases input and other)
|
||
out3 = paddle.dist(input=x, other=y, p=2.0)
|
||
# 4. Class method positional arguments
|
||
out4 = x.dist(y, 2.0)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.dist(y=y, p=2.0)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x, "y": self.np_y},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
|
||
# Verify all outputs
|
||
ref_out = float(np.linalg.norm((self.np_x - self.np_y).flatten()))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test flip compatibility
|
||
class TestFlipAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 2, 2).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.flip(x, [0, 1])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.flip(x=x, axis=[0, 1])
|
||
# 3. PyTorch keyword arguments (using aliases input and dims)
|
||
out3 = paddle.flip(input=x, dims=[0, 1])
|
||
# 4. Mixed arguments
|
||
out4 = paddle.flip(x, axis=[0, 1])
|
||
# 5. Class method positional arguments
|
||
out5 = x.flip([0, 1])
|
||
# 6. Class method keyword arguments
|
||
out6 = x.flip(axis=[0, 1])
|
||
|
||
# Verify all outputs
|
||
ref_out = np.flip(self.np_x, axis=[0, 1])
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=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=[3, 2, 2], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.flip(x, [0, 1])
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.flip(x=x, axis=[0, 1])
|
||
# 3. PyTorch keyword arguments (using aliases input and dims)
|
||
out3 = paddle.flip(input=x, dims=[0, 1])
|
||
# 4. Class method positional arguments
|
||
out4 = x.flip([0, 1])
|
||
# 5. Class method keyword arguments
|
||
out5 = x.flip(axis=[0, 1])
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.flip(self.np_x, axis=[0, 1])
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test count_nonzero compatibility
|
||
class TestCountNonzeroAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.randint(-1, 2, [3, 4, 5]).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
ref_axis = np.count_nonzero(self.np_x, axis=1, keepdims=True)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.count_nonzero(x, 1, True)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.count_nonzero(x=x, axis=1, keepdim=True)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.count_nonzero(input=x, dim=1, keepdim=True)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.count_nonzero(x, axis=1, keepdim=True)
|
||
# 5. Class method positional arguments
|
||
out5 = x.count_nonzero(1, True)
|
||
# 6. Class method keyword arguments
|
||
out6 = x.count_nonzero(dim=1, keepdim=True)
|
||
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_axis)
|
||
|
||
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, 4, 5], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.count_nonzero(x, 1, True)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.count_nonzero(x=x, axis=1, keepdim=True)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.count_nonzero(input=x, dim=1, keepdim=True)
|
||
# 4. Class method positional arguments
|
||
out4 = x.count_nonzero(1, True)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.count_nonzero(dim=1, keepdim=True)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
ref = np.count_nonzero(self.np_x, axis=1, keepdims=True)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref)
|
||
|
||
|
||
# Test renorm compatibility
|
||
class TestRenormAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(2, 2, 3).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments (all positional: x, p, axis, max_norm）
|
||
out1 = paddle.renorm(x, 1.0, 2, 2.05)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.renorm(x=x, p=1.0, axis=2, max_norm=2.05)
|
||
# 3. PyTorch keyword arguments (using aliases input, dim, maxnorm)
|
||
out3 = paddle.renorm(input=x, p=1.0, dim=2, maxnorm=2.05)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.renorm(x, p=1.0, axis=2, max_norm=2.05)
|
||
# 5. Class method positional arguments
|
||
out5 = x.renorm(1.0, 2, 2.05)
|
||
# 6. Class method keyword arguments
|
||
out6 = x.renorm(p=1.0, axis=2, max_norm=2.05)
|
||
|
||
# Verify all outputs
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=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=[2, 2, 3], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: x, p, axis, max_norm）
|
||
out1 = paddle.renorm(x, 1.0, 2, 2.05)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.renorm(x=x, p=1.0, axis=2, max_norm=2.05)
|
||
# 3. PyTorch keyword arguments (using aliases input, dim, maxnorm)
|
||
out3 = paddle.renorm(input=x, p=1.0, dim=2, maxnorm=2.05)
|
||
# 4. Class method positional arguments
|
||
out4 = x.renorm(1.0, 2, 2.05)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.renorm(p=1.0, axis=2, max_norm=2.05)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
|
||
# Verify all outputs
|
||
for out in fetches[1:]:
|
||
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
||
|
||
|
||
# Test renorm_ inplace compatibility
|
||
class TestRenormInplaceAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(2, 2, 3).astype('float32')
|
||
|
||
def test_dygraph_inplace_Compatibility(self):
|
||
paddle.disable_static()
|
||
ref_x = self.np_x.copy()
|
||
|
||
# 1. Class method positional arguments
|
||
out1 = paddle.to_tensor(ref_x)
|
||
out1.renorm_(1.0, 2, 2.05)
|
||
# 2. Class method keyword arguments
|
||
out2 = paddle.to_tensor(ref_x)
|
||
out2.renorm_(p=1.0, axis=2, max_norm=2.05)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.to_tensor(ref_x)
|
||
out3.renorm_(p=1.0, dim=2, maxnorm=2.05)
|
||
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
||
|
||
paddle.enable_static()
|
||
|
||
|
||
# Test unique compatibility
|
||
class TestUniqueAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.x_1d = np.array([3, 1, 2, 1, 3]).astype('int64')
|
||
self.x_2d = np.array([[2, 1, 3], [3, 0, 1], [2, 1, 3]]).astype('int64')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.x_1d)
|
||
|
||
# 1. Paddle positional arguments (all positional: x, return_index, return_inverse, return_counts, axis, dtype, sorted）
|
||
out1 = paddle.unique(x, False, False, False, None, 'int64', True)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.unique(
|
||
x=x,
|
||
return_index=False,
|
||
return_inverse=False,
|
||
return_counts=False,
|
||
axis=None,
|
||
dtype='int64',
|
||
sorted=True,
|
||
)
|
||
# 3. PyTorch keyword arguments (using aliases input and dim)
|
||
out3 = paddle.unique(input=x, sorted=True)
|
||
# 4. Mixed arguments (positional + keyword)
|
||
out4 = paddle.unique(x, sorted=False)
|
||
# 5. Class method positional arguments
|
||
out5 = x.unique()
|
||
# 6. Class method keyword arguments
|
||
out6 = x.unique(sorted=True)
|
||
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
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=[5], dtype='int64')
|
||
# 1. Paddle positional arguments (all positional arguments)
|
||
out1 = paddle.unique(x, False, False, False, None, 'int64', True)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.unique(
|
||
x=x,
|
||
return_index=False,
|
||
return_inverse=False,
|
||
return_counts=False,
|
||
axis=None,
|
||
dtype='int64',
|
||
sorted=True,
|
||
)
|
||
# 3. PyTorch keyword arguments (using aliases)
|
||
out3 = paddle.unique(input=x, sorted=True)
|
||
# 4. Class method positional arguments
|
||
out4 = x.unique()
|
||
# 5. Class method keyword arguments
|
||
out5 = x.unique(sorted=True)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.x_1d},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
for i in range(1, len(fetches)):
|
||
np.testing.assert_array_equal(fetches[0], fetches[i])
|
||
|
||
|
||
class TestCloneAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 4).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.clone(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.clone(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.clone(input=x)
|
||
# 4. Mixed arguments
|
||
# clone only has one parameter x, mixed arguments not applicable
|
||
# 5. Class method positional arguments
|
||
out4 = x.clone()
|
||
# 6. Class method keyword arguments
|
||
# clone class method has no parameters, keyword arguments not applicable
|
||
|
||
for out in [out1, out2, out3, out4]:
|
||
np.testing.assert_allclose(out.numpy(), self.np_x)
|
||
self.assertIsNot(out, x)
|
||
|
||
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, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.clone(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.clone(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.clone(input=x)
|
||
# 4. Class method positional arguments
|
||
out4 = x.clone()
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4],
|
||
)
|
||
|
||
# Verify all outputs match input
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, self.np_x)
|
||
|
||
|
||
# Edit By AI Agent
|
||
# Test _assert compatibility
|
||
class TestAssertAPI(unittest.TestCase):
|
||
def test_dygraph_non_tensor_pass(self):
|
||
"""Test _assert with non-tensor condition that passes."""
|
||
paddle.disable_static()
|
||
paddle._assert(True, "should pass")
|
||
paddle._assert(1, "should pass")
|
||
paddle._assert(1 == 1, "should pass")
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_non_tensor_fail(self):
|
||
"""Test _assert with non-tensor condition that fails."""
|
||
paddle.disable_static()
|
||
with self.assertRaises(AssertionError) as ctx:
|
||
paddle._assert(False, "error message")
|
||
self.assertEqual(str(ctx.exception), "error message")
|
||
|
||
with self.assertRaises(AssertionError) as ctx:
|
||
paddle._assert(0, "zero is falsy")
|
||
self.assertEqual(str(ctx.exception), "zero is falsy")
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_tensor_pass(self):
|
||
"""Test _assert with tensor condition that passes."""
|
||
paddle.disable_static()
|
||
cond = paddle.to_tensor([True])
|
||
paddle._assert(cond, "tensor assert should pass")
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_tensor_fail(self):
|
||
"""Test _assert with tensor condition that fails."""
|
||
paddle.disable_static()
|
||
cond = paddle.to_tensor([False])
|
||
with self.assertRaises(AssertionError):
|
||
paddle._assert(cond, "tensor assert should fail")
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_default_message(self):
|
||
"""Test _assert with default empty message."""
|
||
paddle.disable_static()
|
||
with self.assertRaises(AssertionError) as ctx:
|
||
paddle._assert(False)
|
||
self.assertEqual(str(ctx.exception), "")
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_compatibility_with_torch(self):
|
||
"""Test that paddle._assert matches torch._assert calling convention."""
|
||
paddle.disable_static()
|
||
# Positional args (matching torch._assert(condition, message))
|
||
paddle._assert(True, "positional args")
|
||
|
||
# Keyword args (matching torch._assert(condition=..., message=...))
|
||
paddle._assert(condition=True, message="keyword args")
|
||
|
||
# Mixed args
|
||
paddle._assert(True, message="mixed args")
|
||
paddle.enable_static()
|
||
|
||
def test_static_tensor_condition(self):
|
||
"""Test _assert with tensor condition in static graph mode."""
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
with paddle.base.program_guard(main, startup):
|
||
cond = paddle.full(shape=[1], fill_value=True, dtype='bool')
|
||
paddle._assert(cond, "static assert")
|
||
|
||
exe = paddle.base.Executor(paddle.CPUPlace())
|
||
exe.run(main)
|
||
|
||
|
||
class TestHsplitAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x_2d = np.random.rand(7, 8).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x_2d = paddle.to_tensor(self.np_x_2d)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.hsplit(x_2d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.hsplit(x=x_2d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.hsplit(input=x_2d, indices=2)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.hsplit(x_2d, num_or_indices=2)
|
||
# 5. Class method positional arguments
|
||
out5 = x_2d.hsplit(2)
|
||
# 6. Class method keyword arguments
|
||
out6 = x_2d.hsplit(num_or_indices=2)
|
||
|
||
ref_out = np.array_split(self.np_x_2d, 2, axis=1)
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
self.assertEqual(len(out), 2)
|
||
for ref, out_item in zip(ref_out, out):
|
||
np.testing.assert_allclose(ref, out_item.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_2d = paddle.static.data(
|
||
name="x_2d", shape=[7, 8], dtype='float32'
|
||
)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.hsplit(x_2d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.hsplit(x=x_2d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.hsplit(input=x_2d, indices=2)
|
||
# 4. Class method positional arguments
|
||
out4 = x_2d.hsplit(2)
|
||
# 5. Class method keyword arguments
|
||
out5 = x_2d.hsplit(num_or_indices=2)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x_2d": self.np_x_2d},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
ref_out = np.array_split(self.np_x_2d, 2, axis=1)
|
||
for i in range(0, 10, 2):
|
||
np.testing.assert_allclose(fetches[i], ref_out[0])
|
||
np.testing.assert_allclose(fetches[i + 1], ref_out[1])
|
||
|
||
|
||
class TestDsplitAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x_3d = np.random.rand(7, 6, 8).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x_3d = paddle.to_tensor(self.np_x_3d)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.dsplit(x_3d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.dsplit(x=x_3d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.dsplit(input=x_3d, indices=2)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.dsplit(x_3d, num_or_indices=2)
|
||
# 5. Class method positional arguments
|
||
out5 = x_3d.dsplit(2)
|
||
# 6. Class method keyword arguments
|
||
out6 = x_3d.dsplit(num_or_indices=2)
|
||
|
||
ref_out = np.array_split(self.np_x_3d, 2, axis=2)
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
self.assertEqual(len(out), 2)
|
||
for ref, out_item in zip(ref_out, out):
|
||
np.testing.assert_allclose(ref, out_item.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_3d = paddle.static.data(
|
||
name="x_3d", shape=[7, 6, 8], dtype='float32'
|
||
)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.dsplit(x_3d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.dsplit(x=x_3d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.dsplit(input=x_3d, indices=2)
|
||
# 4. Class method positional arguments
|
||
out4 = x_3d.dsplit(2)
|
||
# 5. Class method keyword arguments
|
||
out5 = x_3d.dsplit(num_or_indices=2)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x_3d": self.np_x_3d},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
ref_out = np.array_split(self.np_x_3d, 2, axis=2)
|
||
for i in range(0, 10, 2):
|
||
np.testing.assert_allclose(fetches[i], ref_out[0])
|
||
np.testing.assert_allclose(fetches[i + 1], ref_out[1])
|
||
|
||
|
||
class TestVsplitAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x_2d = np.random.rand(8, 6).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x_2d = paddle.to_tensor(self.np_x_2d)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.vsplit(x_2d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.vsplit(x=x_2d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.vsplit(input=x_2d, indices=2)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.vsplit(x_2d, num_or_indices=2)
|
||
# 5. Class method positional arguments
|
||
out5 = x_2d.vsplit(2)
|
||
# 6. Class method keyword arguments
|
||
out6 = x_2d.vsplit(num_or_indices=2)
|
||
|
||
ref_out = np.array_split(self.np_x_2d, 2, axis=0)
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
self.assertEqual(len(out), 2)
|
||
for ref, out_item in zip(ref_out, out):
|
||
np.testing.assert_allclose(ref, out_item.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_2d = paddle.static.data(
|
||
name="x_2d", shape=[8, 6], dtype='float32'
|
||
)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.vsplit(x_2d, 2)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.vsplit(x=x_2d, num_or_indices=2)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.vsplit(input=x_2d, indices=2)
|
||
# 4. Class method positional arguments
|
||
out4 = x_2d.vsplit(2)
|
||
# 5. Class method keyword arguments
|
||
out5 = x_2d.vsplit(num_or_indices=2)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x_2d": self.np_x_2d},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
ref_out = np.array_split(self.np_x_2d, 2, axis=0)
|
||
for i in range(0, 10, 2):
|
||
np.testing.assert_allclose(fetches[i], ref_out[0])
|
||
np.testing.assert_allclose(fetches[i + 1], ref_out[1])
|
||
|
||
|
||
# Test hstack compatibility
|
||
class TestHstackAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.inputs = [
|
||
np.random.rand(2, 3).astype('float32'),
|
||
np.random.rand(2, 4).astype('float32'),
|
||
]
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
tensors = [paddle.to_tensor(inp) for inp in self.inputs]
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.hstack(tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.hstack(x=tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.hstack(tensors=tensors)
|
||
# 4. Mixed arguments (only one parameter, mixed not applicable)
|
||
|
||
ref_out = np.hstack(tuple(inp for inp in self.inputs))
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(
|
||
ref_out, out.numpy(), rtol=1e-5, atol=1e-8
|
||
)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
shapes = [[2, 3], [2, 4]]
|
||
with paddle.static.program_guard(main, startup):
|
||
static_tensors = []
|
||
feed_dict = {}
|
||
for i, (shape, inp) in enumerate(zip(shapes, self.inputs)):
|
||
static_tensor = paddle.static.data(
|
||
name=f"x{i}", shape=shape, dtype='float32'
|
||
)
|
||
static_tensors.append(static_tensor)
|
||
feed_dict[f"x{i}"] = inp
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.hstack(static_tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.hstack(x=static_tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.hstack(tensors=static_tensors)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main, feed=feed_dict, fetch_list=[out1, out2, out3]
|
||
)
|
||
ref_out = np.hstack(tuple(inp for inp in self.inputs))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-8)
|
||
|
||
|
||
class TestVstackAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.inputs = [
|
||
np.random.rand(2, 3).astype('float32'),
|
||
np.random.rand(3, 3).astype('float32'),
|
||
]
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
tensors = [paddle.to_tensor(inp) for inp in self.inputs]
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.vstack(tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.vstack(x=tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.vstack(tensors=tensors)
|
||
|
||
ref_out = np.vstack(tuple(inp for inp in self.inputs))
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(
|
||
ref_out, out.numpy(), rtol=1e-5, atol=1e-8
|
||
)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
shapes = [[2, 3], [3, 3]]
|
||
with paddle.static.program_guard(main, startup):
|
||
static_tensors = []
|
||
feed_dict = {}
|
||
for i, (shape, inp) in enumerate(zip(shapes, self.inputs)):
|
||
static_tensor = paddle.static.data(
|
||
name=f"x{i}", shape=shape, dtype='float32'
|
||
)
|
||
static_tensors.append(static_tensor)
|
||
feed_dict[f"x{i}"] = inp
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.vstack(static_tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.vstack(x=static_tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.vstack(tensors=static_tensors)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main, feed=feed_dict, fetch_list=[out1, out2, out3]
|
||
)
|
||
|
||
ref_out = np.vstack(tuple(inp for inp in self.inputs))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-8)
|
||
|
||
|
||
# Test dstack compatibility
|
||
class TestDstackAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.inputs = [
|
||
np.random.rand(2, 3, 4).astype('float32'),
|
||
np.random.rand(2, 3, 4).astype('float32'),
|
||
]
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
tensors = [paddle.to_tensor(inp) for inp in self.inputs]
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.dstack(tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.dstack(x=tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.dstack(tensors=tensors)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.dstack(tuple(inp for inp in self.inputs))
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(
|
||
ref_out, out.numpy(), rtol=1e-5, atol=1e-8
|
||
)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
shapes = [[2, 3, 4], [2, 3, 4]]
|
||
with paddle.static.program_guard(main, startup):
|
||
static_tensors = []
|
||
feed_dict = {}
|
||
for i, (shape, inp) in enumerate(zip(shapes, self.inputs)):
|
||
static_tensor = paddle.static.data(
|
||
name=f"x{i}", shape=shape, dtype='float32'
|
||
)
|
||
static_tensors.append(static_tensor)
|
||
feed_dict[f"x{i}"] = inp
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.dstack(static_tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.dstack(x=static_tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.dstack(tensors=static_tensors)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main, feed=feed_dict, fetch_list=[out1, out2, out3]
|
||
)
|
||
|
||
ref_out = np.dstack(tuple(inp for inp in self.inputs))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-8)
|
||
|
||
|
||
# Test column_stack compatibility
|
||
class TestColumnStackAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.inputs = [
|
||
np.random.rand(3, 2).astype('float32'),
|
||
np.random.rand(3, 3).astype('float32'),
|
||
]
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
tensors = [paddle.to_tensor(inp) for inp in self.inputs]
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.column_stack(tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.column_stack(x=tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.column_stack(tensors=tensors)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.column_stack(tuple(inp for inp in self.inputs))
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(
|
||
ref_out, out.numpy(), rtol=1e-5, atol=1e-8
|
||
)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
shapes = [[3, 2], [3, 3]]
|
||
with paddle.static.program_guard(main, startup):
|
||
static_tensors = []
|
||
feed_dict = {}
|
||
for i, (shape, inp) in enumerate(zip(shapes, self.inputs)):
|
||
static_tensor = paddle.static.data(
|
||
name=f"x{i}", shape=shape, dtype='float32'
|
||
)
|
||
static_tensors.append(static_tensor)
|
||
feed_dict[f"x{i}"] = inp
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.column_stack(static_tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.column_stack(x=static_tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.column_stack(tensors=static_tensors)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main, feed=feed_dict, fetch_list=[out1, out2, out3]
|
||
)
|
||
|
||
ref_out = np.column_stack(tuple(inp for inp in self.inputs))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-8)
|
||
|
||
|
||
# Test row_stack compatibility
|
||
class TestRowStackAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.inputs = [
|
||
np.random.rand(2, 3).astype('float32'),
|
||
np.random.rand(4, 3).astype('float32'),
|
||
]
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
tensors = [paddle.to_tensor(inp) for inp in self.inputs]
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.row_stack(tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.row_stack(x=tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.row_stack(tensors=tensors)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.vstack(tuple(inp for inp in self.inputs))
|
||
for out in [out1, out2, out3]:
|
||
np.testing.assert_allclose(
|
||
ref_out, out.numpy(), rtol=1e-5, atol=1e-8
|
||
)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
shapes = [[2, 3], [4, 3]]
|
||
with paddle.static.program_guard(main, startup):
|
||
static_tensors = []
|
||
feed_dict = {}
|
||
for i, (shape, inp) in enumerate(zip(shapes, self.inputs)):
|
||
static_tensor = paddle.static.data(
|
||
name=f"x{i}", shape=shape, dtype='float32'
|
||
)
|
||
static_tensors.append(static_tensor)
|
||
feed_dict[f"x{i}"] = inp
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.row_stack(static_tensors)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.row_stack(x=static_tensors)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.row_stack(tensors=static_tensors)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main, feed=feed_dict, fetch_list=[out1, out2, out3]
|
||
)
|
||
|
||
ref_out = np.vstack(tuple(inp for inp in self.inputs))
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-8)
|
||
|
||
|
||
# Test bernoulli compatibility
|
||
class TestBernoulliAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(2, 3).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.bernoulli(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.bernoulli(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.bernoulli(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.bernoulli(x, p=0.5)
|
||
# 5-6. out parameter test
|
||
out5 = paddle.empty_like(x)
|
||
out6 = paddle.bernoulli(x, out=out5)
|
||
# 7. Class method positional arguments
|
||
out7 = x.bernoulli()
|
||
# 8. Class method keyword arguments
|
||
out8 = x.bernoulli(p=0.5)
|
||
|
||
# Verify outputs have correct shape
|
||
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
||
self.assertEqual(out.shape, x.shape)
|
||
self.assertEqual(out.dtype, x.dtype)
|
||
|
||
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, 3], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.bernoulli(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.bernoulli(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.bernoulli(input=x)
|
||
|
||
exe = paddle.static.Executor()
|
||
exe.run(startup)
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
# Verify outputs have correct shape
|
||
for out in fetches:
|
||
self.assertEqual(out.shape, (2, 3))
|
||
|
||
|
||
# Test combinations compatibility
|
||
class TestCombinationsAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([1, 2, 3, 4]).astype('int32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments (all positional: x, r, with_replacement）
|
||
out1 = paddle.combinations(x, 2, False)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.combinations(x=x, r=2, with_replacement=False)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.combinations(input=x, r=2)
|
||
# 4. Mixed arguments (with with_replacement parameter)
|
||
out4 = paddle.combinations(x, r=3, with_replacement=True)
|
||
|
||
# Verify all outputs
|
||
for out in [out1, out2, out3, out4]:
|
||
self.assertIsInstance(out, paddle.Tensor)
|
||
|
||
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=[4], dtype='int32')
|
||
|
||
# 1. Paddle positional arguments (all positional: x, r, with_replacement）
|
||
out1 = paddle.combinations(x, 2, False)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.combinations(x=x, r=2, with_replacement=False)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.combinations(input=x, r=2)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
# Verify all outputs
|
||
for out in fetches:
|
||
self.assertIsInstance(out, np.ndarray)
|
||
|
||
|
||
# Test trapezoid compatibility
|
||
class TestTrapezoidAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_y = np.array([4.0, 5.0, 6.0, 7.0, 8.0], dtype='float32')
|
||
self.np_x = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype='float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
y = paddle.to_tensor(self.np_y)
|
||
|
||
# 1. Paddle positional arguments (all positional: y, x, dx, axis）
|
||
out1 = paddle.trapezoid(y, None, None, -1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.trapezoid(y=y, x=None, dx=None, axis=-1)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.trapezoid(y, dim=-1)
|
||
# 4-5. out parameter test
|
||
out4 = paddle.empty([])
|
||
out5 = paddle.trapezoid(y, out=out4)
|
||
assert out4 is out5
|
||
|
||
# Verify outputs
|
||
ref_out = out1.numpy()
|
||
for out in [out1, out2, out3, out4, out5]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=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):
|
||
y = paddle.static.data(name="y", shape=[5], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: y, x, dx, axis）
|
||
out1 = paddle.trapezoid(y, None, None, -1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.trapezoid(y=y, x=None, dx=None, axis=-1)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.trapezoid(y, dim=-1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"y": self.np_y},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
ref_out = fetches[0]
|
||
for out in fetches[1:]:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test cumulative_trapezoid compatibility
|
||
class TestCumulativeTrapezoidAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_y = np.array([4.0, 5.0, 6.0, 7.0, 8.0], dtype='float32')
|
||
self.np_x = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype='float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
y = paddle.to_tensor(self.np_y)
|
||
|
||
# 1. Paddle positional arguments (all positional: y, x, dx, axis）
|
||
out1 = paddle.cumulative_trapezoid(y, None, None, -1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.cumulative_trapezoid(y=y, x=None, dx=None, axis=-1)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.cumulative_trapezoid(y, dim=-1)
|
||
# 4. Mixed arguments (with dx parameter)
|
||
out4 = paddle.cumulative_trapezoid(y, dx=2.0)
|
||
# 5-6. out parameter test
|
||
out5 = paddle.empty([4])
|
||
out6 = paddle.cumulative_trapezoid(y, out=out5)
|
||
assert out5 is out6
|
||
|
||
# Verify outputs
|
||
ref_out = np.array([4.5, 10.0, 16.5, 24.0])
|
||
for out in [out1, out2, out3, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-5)
|
||
# Output with dx=2.0
|
||
ref_out_dx = np.array([9.0, 20.0, 33.0, 48.0])
|
||
np.testing.assert_allclose(out4.numpy(), ref_out_dx, rtol=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):
|
||
y = paddle.static.data(name="y", shape=[5], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: y, x, dx, axis）
|
||
out1 = paddle.cumulative_trapezoid(y, None, None, -1)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.cumulative_trapezoid(y=y, x=None, dx=None, axis=-1)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.cumulative_trapezoid(y, dim=-1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"y": self.np_y},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
ref_out = np.array([4.5, 10.0, 16.5, 24.0])
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test frexp compatibility
|
||
class TestFrexpAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[10.0, -2.5, 0.0, 3.14], [128.0, 64.0, -32.0, 16.0]],
|
||
dtype='float32',
|
||
)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.frexp(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.frexp(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.frexp(input=x)
|
||
# 4. out parameter (tuple)
|
||
out4 = (paddle.empty_like(x), paddle.empty_like(x))
|
||
paddle.frexp(input=x, out=out4)
|
||
# 5. out parameter (list)
|
||
out5 = [paddle.empty_like(x), paddle.empty_like(x)]
|
||
paddle.frexp(input=x, out=out5)
|
||
# 5. Tensor method
|
||
out6 = x.frexp()
|
||
|
||
# Verify all outputs are consistent
|
||
ref_mantissa = out1[0].numpy()
|
||
ref_exponent = out1[1].numpy()
|
||
|
||
for out in [out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out[0].numpy(), ref_mantissa, rtol=1e-5)
|
||
np.testing.assert_allclose(out[1].numpy(), ref_exponent, rtol=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=[2, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
mantissa1, exponent1 = paddle.frexp(x)
|
||
# 2. Paddle keyword arguments
|
||
mantissa2, exponent2 = paddle.frexp(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
mantissa3, exponent3 = paddle.frexp(input=x)
|
||
# 4. Mixed arguments (only one parameter, mixed not applicable)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
mantissa1,
|
||
exponent1,
|
||
mantissa2,
|
||
exponent2,
|
||
mantissa3,
|
||
exponent3,
|
||
],
|
||
)
|
||
|
||
# Verify all outputs are consistent
|
||
for i in range(0, len(fetches), 2):
|
||
np.testing.assert_allclose(fetches[i], fetches[0], rtol=1e-5)
|
||
np.testing.assert_allclose(
|
||
fetches[i + 1], fetches[1], rtol=1e-5
|
||
)
|
||
|
||
|
||
# Test lgamma compatibility
|
||
class TestLgammaAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([-0.4, -0.2, 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.lgamma(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.lgamma(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.lgamma(input=x)
|
||
# 4-5. out parameter test
|
||
out4 = paddle.empty_like(x)
|
||
out5 = paddle.lgamma(x, out=out4)
|
||
# 6. Class method positional arguments
|
||
out6 = x.lgamma()
|
||
|
||
# Verify all outputs
|
||
ref_out = np.array(
|
||
[1.31452465, 1.76149750, 2.25271273, 1.09579802], dtype=np.float32
|
||
)
|
||
for out in [out1, out2, out3, out4, out5, out6]:
|
||
np.testing.assert_allclose(out.numpy(), ref_out, rtol=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=[4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.lgamma(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.lgamma(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.lgamma(input=x)
|
||
# 4. Mixed arguments (only one parameter, mixed not applicable)
|
||
# 5. Class method positional arguments
|
||
out4 = x.lgamma()
|
||
# 6. Class method keyword arguments (no parameters, not applicable)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4],
|
||
)
|
||
|
||
ref_out = np.array(
|
||
[1.31452465, 1.76149750, 2.25271273, 1.09579802],
|
||
dtype=np.float32,
|
||
)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, ref_out, rtol=1e-5)
|
||
|
||
|
||
# Test kron compatibility
|
||
class TestKronAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([[1, 2], [3, 4]], dtype='int64')
|
||
self.np_y = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64')
|
||
|
||
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.kron(x, y)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.kron(x=x, y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.kron(input=x, other=y)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.kron(x, other=y)
|
||
# 5-6. out parameter test
|
||
out5 = paddle.empty([6, 6], dtype='int64')
|
||
out6 = paddle.kron(x, y, out=out5)
|
||
# 7. Class method positional arguments
|
||
out7 = x.kron(y)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.kron(y=y)
|
||
|
||
# Verify all outputs
|
||
ref_out = np.array(
|
||
[
|
||
[1, 2, 3, 2, 4, 6],
|
||
[4, 5, 6, 8, 10, 12],
|
||
[7, 8, 9, 14, 16, 18],
|
||
[3, 6, 9, 4, 8, 12],
|
||
[12, 15, 18, 16, 20, 24],
|
||
[21, 24, 27, 28, 32, 36],
|
||
],
|
||
dtype=np.int64,
|
||
)
|
||
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
||
np.testing.assert_array_equal(out.numpy(), ref_out)
|
||
|
||
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, 2], dtype='int64')
|
||
y = paddle.static.data(name="y", shape=[3, 3], dtype='int64')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.kron(x, y)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.kron(x=x, y=y)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.kron(input=x, other=y)
|
||
# 4. Class method positional arguments
|
||
out4 = x.kron(y)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.kron(y=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.array(
|
||
[
|
||
[1, 2, 3, 2, 4, 6],
|
||
[4, 5, 6, 8, 10, 12],
|
||
[7, 8, 9, 14, 16, 18],
|
||
[3, 6, 9, 4, 8, 12],
|
||
[12, 15, 18, 16, 20, 24],
|
||
[21, 24, 27, 28, 32, 36],
|
||
],
|
||
dtype=np.int64,
|
||
)
|
||
for out in fetches:
|
||
np.testing.assert_array_equal(out, ref_out)
|
||
|
||
|
||
# Test kthvalue compatibility
|
||
class TestKthvalueAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[
|
||
[
|
||
[0.11855337, -0.30557564],
|
||
[-0.09968963, 0.41220093],
|
||
[1.24004936, 1.50014710],
|
||
],
|
||
[
|
||
[0.08612321, -0.92485696],
|
||
[-0.09276631, 1.15149164],
|
||
[-1.46587241, 1.22873247],
|
||
],
|
||
]
|
||
).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
k = 2
|
||
|
||
# 1. Paddle positional arguments (all positional: x, k, axis, keepdim）
|
||
out1 = paddle.kthvalue(x, k, 1, False)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.kthvalue(x=x, k=k, axis=1, keepdim=False)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.kthvalue(input=x, k=k, dim=1)
|
||
# 4. Mixed arguments (with keepdim parameter)
|
||
out4 = paddle.kthvalue(x, k, axis=1, keepdim=True)
|
||
# 5. out parameter test (tuple)
|
||
out5 = (
|
||
paddle.empty([2, 2], dtype='float32'),
|
||
paddle.empty([2, 2], dtype='int64'),
|
||
)
|
||
paddle.kthvalue(x, k, axis=1, out=out5)
|
||
# 6. out parameter test (list)
|
||
# TODO(zhwesky2010): should fix out is list
|
||
# out6 = [
|
||
# paddle.empty([2, 2], dtype='float32'),
|
||
# paddle.empty([2, 2], dtype='int64'),
|
||
# ]
|
||
# paddle.kthvalue(x, k, axis=1, out=out6)
|
||
# 7. Class method positional arguments
|
||
out7 = x.kthvalue(k, 1)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.kthvalue(k, axis=1, keepdim=True)
|
||
|
||
# Verify outputs
|
||
ref_values = np.array(
|
||
[[[0.11855337, 0.41220093], [-0.09276631, 1.15149164]]],
|
||
dtype=np.float32,
|
||
).reshape(2, 2)
|
||
ref_indices = np.array([[0, 1], [1, 1]], dtype=np.int64)
|
||
for out in [out1, out2, out3, out5, out7]:
|
||
np.testing.assert_allclose(out[0].numpy(), ref_values, rtol=1e-5)
|
||
np.testing.assert_array_equal(out[1].numpy(), ref_indices)
|
||
# Verify keepdim=True
|
||
for out in [out4, out8]:
|
||
np.testing.assert_allclose(
|
||
out[0].numpy(), ref_values.reshape(2, 1, 2), rtol=1e-5
|
||
)
|
||
np.testing.assert_array_equal(
|
||
out[1].numpy(), ref_indices.reshape(2, 1, 2)
|
||
)
|
||
|
||
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, 3, 2], dtype='float32')
|
||
k = 2
|
||
|
||
# 1. Paddle positional arguments (all positional: x, k, axis, keepdim）
|
||
values1, indices1 = paddle.kthvalue(x, k, 1, False)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
values2, indices2 = paddle.kthvalue(x=x, k=k, axis=1, keepdim=False)
|
||
# 3. PyTorch keyword arguments
|
||
values3, indices3 = paddle.kthvalue(input=x, k=k, dim=1)
|
||
# 4. Class method positional arguments
|
||
values4, indices4 = x.kthvalue(k, 1)
|
||
# 5. Class method keyword arguments
|
||
values5, indices5 = x.kthvalue(k, axis=1, keepdim=True)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
values1,
|
||
indices1,
|
||
values2,
|
||
indices2,
|
||
values3,
|
||
indices3,
|
||
values4,
|
||
indices4,
|
||
values5,
|
||
indices5,
|
||
],
|
||
)
|
||
|
||
ref_values = np.array(
|
||
[[0.11855337, 0.41220093], [-0.09276631, 1.15149164]],
|
||
dtype=np.float32,
|
||
)
|
||
ref_indices = np.array([[0, 1], [1, 1]], dtype=np.int64)
|
||
# Verify all values outputs (no keepdim)
|
||
for i in [0, 2, 4, 6]:
|
||
np.testing.assert_allclose(fetches[i], ref_values, rtol=1e-5)
|
||
# Verify keepdim=True values
|
||
np.testing.assert_allclose(
|
||
fetches[8], ref_values.reshape(2, 1, 2), rtol=1e-5
|
||
)
|
||
# Verify all indices outputs (no keepdim)
|
||
for i in [1, 3, 5, 7]:
|
||
np.testing.assert_array_equal(fetches[i], ref_indices)
|
||
# Verify keepdim=True indices
|
||
np.testing.assert_array_equal(
|
||
fetches[9], ref_indices.reshape(2, 1, 2)
|
||
)
|
||
|
||
|
||
# Test logcumsumexp compatibility
|
||
class TestLogcumsumexpAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.arange(12, dtype=np.float32).reshape(3, 4)
|
||
self.ref_out_axis0 = np.array(
|
||
[
|
||
[0.0, 1.0, 2.0, 3.0],
|
||
[4.01814993, 5.01814993, 6.01814993, 7.01814993],
|
||
[8.01847930, 9.01847930, 10.01847930, 11.01847930],
|
||
]
|
||
)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments (all positional: x, axis, dtype）
|
||
out1 = paddle.logcumsumexp(x, 0, None)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.logcumsumexp(x=x, axis=0, dtype=None)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.logcumsumexp(input=x, dim=0)
|
||
# 4. Mixed arguments (with dtype parameter)
|
||
out4 = paddle.logcumsumexp(x, axis=0, dtype='float32')
|
||
# 5-6. out parameter test
|
||
out5 = paddle.empty([3, 4], dtype='float32')
|
||
out6 = paddle.logcumsumexp(x, axis=0, out=out5)
|
||
# 7. Class method positional arguments
|
||
out7 = x.logcumsumexp(0)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.logcumsumexp(axis=0)
|
||
|
||
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
||
np.testing.assert_allclose(
|
||
out.numpy(), self.ref_out_axis0, rtol=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=[3, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments (all positional: x, axis, dtype）
|
||
out1 = paddle.logcumsumexp(x, 0, None)
|
||
# 2. Paddle keyword arguments (all keyword arguments)
|
||
out2 = paddle.logcumsumexp(x=x, axis=0, dtype=None)
|
||
# 3. PyTorch keyword arguments (using alias dim)
|
||
out3 = paddle.logcumsumexp(input=x, dim=0)
|
||
# 4. Class method positional arguments
|
||
out4 = x.logcumsumexp(0)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.logcumsumexp(axis=0)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5],
|
||
)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, self.ref_out_axis0, rtol=1e-5)
|
||
|
||
|
||
# Test poisson compatibility
|
||
class TestPoissonAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
np.random.seed(2025)
|
||
self.np_x = np.random.rand(3, 4).astype('float32') + 0.5
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
paddle.seed(100)
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.poisson(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.poisson(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.poisson(input=x)
|
||
# 4. Mixed arguments (only one parameter, mixed not applicable)
|
||
|
||
# Verify all outputs have same shape
|
||
for out in [out1, out2, out3]:
|
||
self.assertEqual(out.shape, (3, 4))
|
||
self.assertEqual(out.dtype, x.dtype)
|
||
|
||
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, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.poisson(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.poisson(x=x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.poisson(input=x)
|
||
# 4. Mixed arguments (only one parameter, mixed not applicable)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3],
|
||
)
|
||
|
||
# Verify all outputs have correct shape
|
||
for out in fetches:
|
||
self.assertEqual(out.shape, (3, 4))
|
||
|
||
|
||
# Test cummax compatibility
|
||
class TestCummaxAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([[-1, 5, 0], [-2, -3, 2]], dtype='float32')
|
||
self.ref_values = np.array([[-1, 5, 5], [-2, -2, 2]], dtype='float32')
|
||
self.ref_indices = np.array([[0, 1, 1], [0, 0, 2]], dtype=np.int64)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.cummax(x, 1, 'int64')
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cummax(x=x, axis=1, dtype='int64')
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.cummax(input=x, dim=1)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.cummax(x, axis=1, dtype='int64')
|
||
# 5. out parameter (tuple)
|
||
out5 = (
|
||
paddle.empty([2, 3], dtype='float32'),
|
||
paddle.empty([2, 3], dtype='int64'),
|
||
)
|
||
paddle.cummax(x, 1, out=out5)
|
||
# 6. out parameter (list)
|
||
out6 = [
|
||
paddle.empty([2, 3], dtype='float32'),
|
||
paddle.empty([2, 3], dtype='int64'),
|
||
]
|
||
paddle.cummax(x, 1, out=out6)
|
||
# 7. Tensor method - positional
|
||
out7 = x.cummax(1)
|
||
# 8. Tensor method - keyword
|
||
out8 = x.cummax(axis=1, dtype='int64')
|
||
|
||
# Verify all outputs
|
||
for out in [out1, out2, out3, out4, out7, out8]:
|
||
np.testing.assert_array_equal(out.values.numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out.indices.numpy(), self.ref_indices)
|
||
for out in [out5, out6]:
|
||
np.testing.assert_array_equal(out[0].numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out[1].numpy(), self.ref_indices)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main, startup = paddle.static.Program(), paddle.static.Program()
|
||
with paddle.static.program_guard(main, startup):
|
||
x = paddle.static.data(name="x", shape=[2, 3], dtype='float32')
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.cummax(x, 1, 'int64')
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cummax(x=x, axis=1, dtype='int64')
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.cummax(input=x, dim=1)
|
||
# 4. Tensor method - positional
|
||
out4 = x.cummax(1)
|
||
# 5. Tensor method - keyword
|
||
out5 = x.cummax(axis=1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
for i in range(0, len(fetches), 2):
|
||
np.testing.assert_array_equal(fetches[i], self.ref_values)
|
||
np.testing.assert_array_equal(fetches[i + 1], self.ref_indices)
|
||
|
||
|
||
# Test cummin compatibility
|
||
class TestCumminAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([[-1, 5, 0], [-2, -3, 2]], dtype='float32')
|
||
self.ref_values = np.array(
|
||
[[-1, -1, -1], [-2, -3, -3]], dtype='float32'
|
||
)
|
||
self.ref_indices = np.array([[0, 0, 0], [0, 1, 1]], dtype=np.int64)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.cummin(x, 1, 'int64')
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cummin(x=x, axis=1, dtype='int64')
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.cummin(input=x, dim=1)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.cummin(x, axis=1, dtype='int64')
|
||
# 5. out parameter (tuple)
|
||
out5 = (
|
||
paddle.empty([2, 3], dtype='float32'),
|
||
paddle.empty([2, 3], dtype='int64'),
|
||
)
|
||
out5 = paddle.cummin(x, 1, out=out5)
|
||
# 6. out parameter (list)
|
||
out6 = [
|
||
paddle.empty([2, 3], dtype='float32'),
|
||
paddle.empty([2, 3], dtype='int64'),
|
||
]
|
||
paddle.cummin(x, 1, out=out6)
|
||
# 7. Tensor method - positional
|
||
out7 = x.cummin(1)
|
||
# 8. Tensor method - keyword
|
||
out8 = x.cummin(axis=1, dtype='int64')
|
||
|
||
# Verify all outputs
|
||
for out in [out1, out2, out3, out4, out7, out8]:
|
||
np.testing.assert_array_equal(out.values.numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out.indices.numpy(), self.ref_indices)
|
||
for out in [out5, out6]:
|
||
np.testing.assert_array_equal(out[0].numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out[1].numpy(), self.ref_indices)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main, startup = paddle.static.Program(), paddle.static.Program()
|
||
with paddle.static.program_guard(main, startup):
|
||
x = paddle.static.data(name="x", shape=[2, 3], dtype='float32')
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.cummin(x, 1, 'int64')
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.cummin(x=x, axis=1, dtype='int64')
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.cummin(input=x, dim=1)
|
||
# 4. Tensor method - positional
|
||
out4 = x.cummin(1)
|
||
# 5. Tensor method - keyword
|
||
out5 = x.cummin(axis=1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
for i in range(0, len(fetches), 2):
|
||
np.testing.assert_array_equal(fetches[i], self.ref_values)
|
||
np.testing.assert_array_equal(fetches[i + 1], self.ref_indices)
|
||
|
||
|
||
# Test mode compatibility
|
||
class TestModeAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
# Use fixed data for precise comparison
|
||
self.np_x = np.array(
|
||
[
|
||
[
|
||
[0.5, 0.3, 0.7, 0.2],
|
||
[0.5, 0.8, 0.7, 0.9],
|
||
[0.1, 0.3, 0.4, 0.2],
|
||
],
|
||
[
|
||
[0.6, 0.4, 0.5, 0.3],
|
||
[0.6, 0.2, 0.5, 0.7],
|
||
[0.9, 0.4, 0.8, 0.3],
|
||
],
|
||
]
|
||
).astype('float32')
|
||
self.ref_values = np.array(
|
||
[[0.5, 0.3, 0.7, 0.2], [0.6, 0.4, 0.5, 0.3]], dtype='float32'
|
||
)
|
||
self.ref_indices = np.array(
|
||
[[1, 2, 1, 2], [1, 2, 1, 2]], dtype=np.int64
|
||
)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.mode(x, 1, False)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.mode(x=x, axis=1, keepdim=False)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.mode(input=x, dim=1)
|
||
# 4. Mixed arguments (with keepdim parameter)
|
||
out4 = paddle.mode(x, axis=1, keepdim=True)
|
||
# 5. out parameter (tuple)
|
||
out5 = (
|
||
paddle.empty([2, 4], dtype='float32'),
|
||
paddle.empty([2, 4], dtype='int64'),
|
||
)
|
||
paddle.mode(x, 1, out=out5)
|
||
# 6. out parameter (list)
|
||
out6 = [
|
||
paddle.empty([2, 4], dtype='float32'),
|
||
paddle.empty([2, 4], dtype='int64'),
|
||
]
|
||
paddle.mode(x, 1, out=out6)
|
||
# 7. Class method positional arguments
|
||
out7 = x.mode(1)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.mode(axis=1, keepdim=True)
|
||
|
||
# Verify outputs with keepdim=False
|
||
for out in [out1, out2, out3, out7]:
|
||
np.testing.assert_array_equal(out.values.numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out.indices.numpy(), self.ref_indices)
|
||
|
||
# Verify outputs with out parameter
|
||
for out in [out5, out6]:
|
||
np.testing.assert_array_equal(out[0].numpy(), self.ref_values)
|
||
np.testing.assert_array_equal(out[1].numpy(), self.ref_indices)
|
||
|
||
# Verify outputs with keepdim=True
|
||
for out in [out4, out8]:
|
||
np.testing.assert_array_equal(
|
||
out[0].numpy(), self.ref_values.reshape(2, 1, 4)
|
||
)
|
||
np.testing.assert_array_equal(
|
||
out[1].numpy(), self.ref_indices.reshape(2, 1, 4)
|
||
)
|
||
|
||
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, 3, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.mode(x, 1, False)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.mode(x=x, axis=1, keepdim=False)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.mode(input=x, dim=1)
|
||
# 4. Class method positional arguments
|
||
out4 = x.mode(1)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.mode(axis=1, keepdim=True)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
# Verify outputs with keepdim=False: out1, out2, out3, out4
|
||
for i in [0, 2, 4, 6]:
|
||
np.testing.assert_allclose(
|
||
fetches[i], self.ref_values, rtol=1e-5, atol=1e-5
|
||
)
|
||
np.testing.assert_array_equal(fetches[i + 1], self.ref_indices)
|
||
|
||
# Verify output with keepdim=True: out5
|
||
np.testing.assert_allclose(
|
||
fetches[8],
|
||
self.ref_values.reshape(2, 1, 4),
|
||
rtol=1e-5,
|
||
atol=1e-5,
|
||
)
|
||
np.testing.assert_array_equal(
|
||
fetches[9], self.ref_indices.reshape(2, 1, 4)
|
||
)
|
||
|
||
|
||
# Test topk compatibility
|
||
class TestTopkAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[0.5, 0.3, 0.9, 0.2], [0.6, 0.8, 0.4, 0.7], [0.1, 0.4, 0.3, 0.5]]
|
||
).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# Reference: top 2 values along axis=1
|
||
ref_values = np.array(
|
||
[[0.9, 0.5], [0.8, 0.7], [0.5, 0.4]], dtype='float32'
|
||
)
|
||
ref_indices = np.array([[2, 0], [1, 3], [3, 1]], dtype=np.int64)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.topk(x, 2, 1)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.topk(x=x, k=2, axis=1)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.topk(input=x, k=2, dim=1)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.topk(x, k=2, axis=1)
|
||
# 5. out parameter (tuple)
|
||
out5 = (
|
||
paddle.empty([3, 2], dtype='float32'),
|
||
paddle.empty([3, 2], dtype='int64'),
|
||
)
|
||
paddle.topk(x, 2, 1, out=out5)
|
||
# 6. out parameter (list)
|
||
out6 = [
|
||
paddle.empty([3, 2], dtype='float32'),
|
||
paddle.empty([3, 2], dtype='int64'),
|
||
]
|
||
paddle.topk(x, 2, 1, out=out6)
|
||
# 7. Class method positional arguments
|
||
out7 = x.topk(2, 1)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.topk(k=2, axis=1)
|
||
|
||
# Verify all outputs
|
||
for out in [out1, out2, out3, out4, out7, out8]:
|
||
np.testing.assert_array_equal(out.values.numpy(), ref_values)
|
||
np.testing.assert_array_equal(out.indices.numpy(), ref_indices)
|
||
for out in [out5, out6]:
|
||
np.testing.assert_array_equal(out[0].numpy(), ref_values)
|
||
np.testing.assert_array_equal(out[1].numpy(), ref_indices)
|
||
|
||
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, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.topk(x, 2, 1)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.topk(x=x, k=2, axis=1)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.topk(input=x, k=2, dim=1)
|
||
# 4. Class method positional arguments
|
||
out4 = x.topk(2, 1)
|
||
# 5. Class method keyword arguments
|
||
out5 = x.topk(k=2, axis=1)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
out1[0],
|
||
out1[1],
|
||
out2[0],
|
||
out2[1],
|
||
out3[0],
|
||
out3[1],
|
||
out4[0],
|
||
out4[1],
|
||
out5[0],
|
||
out5[1],
|
||
],
|
||
)
|
||
|
||
ref_values = np.array(
|
||
[[0.9, 0.5], [0.8, 0.7], [0.5, 0.4]], dtype='float32'
|
||
)
|
||
ref_indices = np.array([[2, 0], [1, 3], [3, 1]], dtype=np.int64)
|
||
|
||
# Verify all outputs
|
||
for i in range(0, len(fetches), 2):
|
||
np.testing.assert_array_equal(fetches[i], ref_values)
|
||
np.testing.assert_array_equal(fetches[i + 1], ref_indices)
|
||
|
||
|
||
# Test nansum compatibility
|
||
class TestNansumAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[float('nan'), 0.3, 0.5, 0.9], [0.1, 0.2, float('-nan'), 0.7]]
|
||
).astype('float32')
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
ref_value = np.nansum(x, axis=1, keepdims=True)
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.nansum(x, 1, None, True)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.nansum(x=x, axis=1, keepdim=True)
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.nansum(x, 1, True)
|
||
# 4. PyTorch keyword arguments
|
||
out4 = paddle.nansum(input=x, dim=1, keepdim=True)
|
||
# 5. Mixed arguments & out parameter
|
||
out5 = paddle.empty([])
|
||
out6 = paddle.nansum(input=x, axis=1, keepdim=True, out=out5)
|
||
# 7. Class method positional arguments
|
||
out7 = x.nansum(1, None, True)
|
||
# 8. Class method keyword arguments
|
||
out8 = x.nansum(axis=1, keepdim=True)
|
||
|
||
for out in [out1, out2, out3, out4, out5, out6, out7, out8]:
|
||
np.testing.assert_array_equal(out.numpy(), ref_value)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_static_Compatibility(self):
|
||
paddle.enable_static()
|
||
main = paddle.static.Program()
|
||
startup = paddle.static.Program()
|
||
ref_value = np.nansum(self.np_x, axis=1, keepdims=True)
|
||
with paddle.static.program_guard(main, startup):
|
||
x = paddle.static.data(name="x", shape=[2, 4], dtype='float32')
|
||
|
||
# 1. Paddle positional arguments
|
||
out1 = paddle.nansum(x, 1, None, True)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.nansum(x=x, axis=1, keepdim=True)
|
||
# 3. PyTorch positional arguments
|
||
out3 = paddle.nansum(x, 1, True)
|
||
# 4. PyTorch keyword arguments
|
||
out4 = paddle.nansum(input=x, dim=1, keepdim=True)
|
||
# 5. Mixed arguments
|
||
out5 = paddle.nansum(input=x, axis=1, keepdim=True)
|
||
# 6. Class method positional arguments
|
||
out6 = x.nansum(1, None, True)
|
||
# 7. Class method keyword arguments
|
||
out7 = x.nansum(axis=1, keepdim=True)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[
|
||
out1,
|
||
out2,
|
||
out3,
|
||
out4,
|
||
out5,
|
||
out6,
|
||
out7,
|
||
],
|
||
)
|
||
for i in range(0, len(fetches)):
|
||
np.testing.assert_array_equal(fetches[i], ref_value)
|
||
|
||
def test_nansum_compat_decorator_raise(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
with self.assertRaises(ValueError):
|
||
out1 = paddle.nansum(x=x, input=x)
|
||
with self.assertRaises(ValueError):
|
||
out2 = paddle.nansum(x, dim=1, axis=1)
|
||
paddle.enable_static()
|
||
|
||
|
||
class TestHardswishAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[-4.0, -3.0, -1.5], [0.0, 2.5, 5.0]], dtype="float32"
|
||
)
|
||
|
||
def _expected(self):
|
||
return (
|
||
self.np_x * np.minimum(np.maximum(self.np_x + 3.0, 0.0), 6.0) / 6.0
|
||
)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.Hardswish(name="hard_name")(x)
|
||
# 2. PyTorch Positional arguments
|
||
out2 = paddle.nn.Hardswish(False)(x)
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.nn.Hardswish(inplace=False)(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.nn.Hardswish(False, name="hard_name")(x)
|
||
# 5. Functional Paddle positional arguments
|
||
out5 = paddle.nn.functional.hardswish(x)
|
||
# 6. Functional Paddle keyword arguments
|
||
out6 = paddle.nn.functional.hardswish(x=x, name="hard_func")
|
||
# 7. Functional PyTorch keyword arguments (alias)
|
||
out7 = paddle.nn.functional.hardswish(input=x, inplace=False)
|
||
|
||
self.assertEqual(
|
||
paddle.nn.Hardswish(True, name="hard_name").extra_repr(),
|
||
"inplace=True, name=hard_name",
|
||
)
|
||
expected = self._expected()
|
||
for out in [out1, out2, out3, out4, out5, out6, out7]:
|
||
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_inplace(self):
|
||
paddle.disable_static()
|
||
expected = self._expected()
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.Hardswish(inplace=True)(x)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, rtol=1e-6)
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.functional.hardswish(x, inplace=True)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype)
|
||
)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.Hardswish(name="hard_name")(x)
|
||
# 2. PyTorch Positional arguments
|
||
out2 = paddle.nn.Hardswish(False)(x)
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.nn.Hardswish(inplace=False)(input=x)
|
||
# 4. Functional Paddle positional arguments
|
||
out4 = paddle.nn.functional.hardswish(x)
|
||
# 5. Functional Paddle keyword arguments
|
||
out5 = paddle.nn.functional.hardswish(x=x, name="hard_func")
|
||
# 6. Functional PyTorch keyword arguments (alias)
|
||
out6 = paddle.nn.functional.hardswish(input=x, inplace=False)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5, out6],
|
||
)
|
||
|
||
expected = self._expected()
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, expected, rtol=1e-6)
|
||
|
||
|
||
class TestReLU6API(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[-2.0, 0.0, 0.5], [5.0, 6.0, 7.5]], dtype="float32"
|
||
)
|
||
|
||
def _expected(self):
|
||
return np.minimum(np.maximum(self.np_x, 0.0), 6.0)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.ReLU6(name="relu_name")(x)
|
||
# 2. PyTorch Positional arguments
|
||
out2 = paddle.nn.ReLU6(False)(x)
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.nn.ReLU6(inplace=False)(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.nn.ReLU6(False, name="relu_name")(x)
|
||
# 5. Functional Paddle positional arguments
|
||
out5 = paddle.nn.functional.relu6(x)
|
||
# 6. Functional Paddle keyword arguments
|
||
out6 = paddle.nn.functional.relu6(x=x, name="relu_func")
|
||
# 7. Functional PyTorch keyword arguments (alias)
|
||
out7 = paddle.nn.functional.relu6(input=x, inplace=False)
|
||
|
||
self.assertEqual(
|
||
paddle.nn.ReLU6(True, name="relu_name").extra_repr(),
|
||
"inplace=True, name=relu_name",
|
||
)
|
||
expected = self._expected()
|
||
for out in [out1, out2, out3, out4, out5, out6, out7]:
|
||
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_inplace(self):
|
||
paddle.disable_static()
|
||
expected = self._expected()
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.ReLU6(inplace=True)(x)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, rtol=1e-6)
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.functional.relu6(x, inplace=True)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype)
|
||
)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.ReLU6(name="relu_name")(x)
|
||
# 2. PyTorch Positional arguments
|
||
out2 = paddle.nn.ReLU6(False)(x)
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.nn.ReLU6(inplace=False)(input=x)
|
||
# 4. Functional Paddle positional arguments
|
||
out4 = paddle.nn.functional.relu6(x)
|
||
# 5. Functional Paddle keyword arguments
|
||
out5 = paddle.nn.functional.relu6(x=x, name="relu_func")
|
||
# 6. Functional PyTorch keyword arguments (alias)
|
||
out6 = paddle.nn.functional.relu6(input=x, inplace=False)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4, out5, out6],
|
||
)
|
||
|
||
expected = self._expected()
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, expected, rtol=1e-6)
|
||
|
||
|
||
class TestELUAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array([-1.0, 0.0, 1.0, 2.0], dtype="float32")
|
||
|
||
def _expected(self):
|
||
return np.where(
|
||
self.np_x > 0, self.np_x, 1.0 * (np.exp(self.np_x) - 1.0)
|
||
)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.ELU()(x)
|
||
# 2. PyTorch positional arguments
|
||
out2 = paddle.nn.ELU(1.0)(x)
|
||
# 3. PyTorch keyword arguments (alias)
|
||
out3 = paddle.nn.ELU(alpha=1.0)(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.nn.ELU(alpha=1.0)(x)
|
||
# 5. Functional Paddle positional arguments
|
||
out5 = paddle.nn.functional.elu(x)
|
||
# 6. Functional Paddle keyword arguments
|
||
out6 = paddle.nn.functional.elu(x=x, alpha=1.0)
|
||
# 7. Functional PyTorch keyword arguments (alias)
|
||
out7 = paddle.nn.functional.elu(input=x, alpha=1.0)
|
||
|
||
expected = self._expected()
|
||
for out in [out1, out2, out3, out4, out5, out6, out7]:
|
||
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6)
|
||
|
||
paddle.enable_static()
|
||
|
||
def test_dygraph_inplace(self):
|
||
paddle.disable_static()
|
||
expected = self._expected()
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.ELU(inplace=True)(x)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, rtol=1e-6)
|
||
|
||
x = paddle.to_tensor(self.np_x)
|
||
out = paddle.nn.functional.elu(x, inplace=True)
|
||
self.assertIs(out, x)
|
||
np.testing.assert_allclose(x.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype)
|
||
)
|
||
|
||
# 1. Paddle keyword arguments
|
||
out1 = paddle.nn.ELU()(x)
|
||
# 2. PyTorch keyword arguments (alias)
|
||
out2 = paddle.nn.ELU(alpha=1.0)(input=x)
|
||
# 3. Functional Paddle positional arguments
|
||
out3 = paddle.nn.functional.elu(x)
|
||
# 4. Functional PyTorch keyword arguments (alias)
|
||
out4 = paddle.nn.functional.elu(input=x, alpha=1.0)
|
||
|
||
exe = paddle.static.Executor()
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4],
|
||
)
|
||
|
||
expected = self._expected()
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, expected, rtol=1e-6)
|
||
|
||
|
||
class TestPReLUAPI(unittest.TestCase):
|
||
def setUp(self):
|
||
self.np_x = np.array(
|
||
[[[[-2.0, 3.0], [4.0, -5.0]], [[1.0, -2.0], [-3.0, 4.0]]]],
|
||
dtype="float32",
|
||
)
|
||
self.np_x64 = self.np_x.astype("float64")
|
||
|
||
def _expected(self, x):
|
||
return np.where(x >= 0, x, 0.5 * x)
|
||
|
||
def test_dygraph_Compatibility(self):
|
||
paddle.disable_static()
|
||
x = paddle.to_tensor(self.np_x)
|
||
|
||
# 1. Paddle Positional arguments
|
||
out1 = paddle.nn.PReLU(2, 0.5)(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.nn.PReLU(num_parameters=2, init=0.5)(x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.nn.PReLU(
|
||
num_parameters=2, init=0.5, device="cpu", dtype="float32"
|
||
)(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.nn.PReLU(2, init=0.5, device="cpu", dtype="float32")(x)
|
||
|
||
expected = self._expected(self.np_x)
|
||
for out in [out1, out2, out3, out4]:
|
||
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6)
|
||
|
||
x64 = paddle.to_tensor(self.np_x64)
|
||
layer64 = paddle.nn.PReLU(2, 0.5, device="cpu", dtype="float64")
|
||
out5 = layer64(input=x64)
|
||
self.assertEqual(layer64._weight.dtype, paddle.float64)
|
||
np.testing.assert_allclose(
|
||
out5.numpy(), self._expected(self.np_x64), 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=self.np_x.shape, dtype=str(self.np_x.dtype)
|
||
)
|
||
|
||
# 1. Paddle Positional arguments
|
||
out1 = paddle.nn.PReLU(2, 0.5)(x)
|
||
# 2. Paddle keyword arguments
|
||
out2 = paddle.nn.PReLU(num_parameters=2, init=0.5)(x)
|
||
# 3. PyTorch keyword arguments
|
||
out3 = paddle.nn.PReLU(
|
||
num_parameters=2, init=0.5, device="cpu", dtype="float32"
|
||
)(input=x)
|
||
# 4. Mixed arguments
|
||
out4 = paddle.nn.PReLU(2, init=0.5, device="cpu", dtype="float32")(
|
||
x
|
||
)
|
||
|
||
exe = paddle.static.Executor()
|
||
exe.run(startup)
|
||
fetches = exe.run(
|
||
main,
|
||
feed={"x": self.np_x},
|
||
fetch_list=[out1, out2, out3, out4],
|
||
)
|
||
|
||
expected = self._expected(self.np_x)
|
||
for out in fetches:
|
||
np.testing.assert_allclose(out, expected, rtol=1e-6)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
unittest.main()
|