# 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()