# 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 math import sys import unittest import numpy as np import paddle class TestDistributionsCategoricalAPI(unittest.TestCase): def setUp(self): self.place = paddle.CPUPlace() self.np_probs = np.array( [[0.2, 0.3, 0.5], [2.0, 3.0, 5.0]], dtype="float32" ) self.np_logits = np.array( [[0.1, 0.2, 0.7], [1.5, 0.5, 0.25]], dtype="float32" ) self.np_zero_probs = np.array( [[0.0, 1.0, 0.0], [0.5, 0.0, 0.5]], dtype="float32" ) self.np_value = np.array([2, 0], dtype="int64") self.np_zero_value = np.array([1, 1], dtype="int64") def tearDown(self): paddle.enable_static() def _logsumexp(self, x): max_value = np.max(x, axis=-1, keepdims=True) return ( np.log(np.sum(np.exp(x - max_value), axis=-1, keepdims=True)) + max_value ) def _take_torch_last_dim(self, x, value=None): if value is None: value = self.np_value return np.take_along_axis(x, value.reshape([-1, 1]), axis=-1).squeeze( -1 ) def test_dygraph_Compatibility(self): import importlib categorical = importlib.import_module( "paddle.compat.distributions.categorical" ) self.assertIs( paddle.compat.distributions, importlib.import_module("paddle.compat.distributions"), ) self.assertIs(paddle.compat.distributions, paddle.compat.distributions) paddle.disable_static() probs = paddle.to_tensor(self.np_probs, place=self.place) logits = paddle.to_tensor(self.np_logits, place=self.place) zero_probs = paddle.to_tensor(self.np_zero_probs, place=self.place) value = paddle.to_tensor(self.np_value, place=self.place) zero_value = paddle.to_tensor(self.np_zero_value, place=self.place) # 1. PyTorch Positional arguments dist1 = categorical.Categorical(probs) out1 = dist1.log_prob(value) # 2. PyTorch keyword arguments dist2 = categorical.Categorical(probs=probs) out2 = dist2.log_prob(value) # 3. PyTorch Positional arguments dist3 = categorical.Categorical(None, logits, False) out3 = dist3.log_prob(value) # 4. PyTorch keyword arguments dist4 = categorical.Categorical( probs=None, logits=logits, validate_args=False ) out4 = dist4.log_prob(value) # 5. Mixed arguments dist5 = categorical.Categorical(None, logits=logits) out5 = dist5.log_prob(value) dist6 = categorical.Categorical(probs=zero_probs) out6 = dist6.log_prob(zero_value) probs_ref = self.np_probs / self.np_probs.sum(-1, keepdims=True) logits_ref = self.np_logits - self._logsumexp(self.np_logits) zero_probs_ref = self.np_zero_probs / self.np_zero_probs.sum( -1, keepdims=True ) paddle_probs_ref = self._take_torch_last_dim(np.log(probs_ref)) eps = np.finfo(self.np_zero_probs.dtype).eps zero_logits_ref = np.log(np.clip(zero_probs_ref, eps, 1 - eps)) zero_log_prob_ref = self._take_torch_last_dim( zero_logits_ref, self.np_zero_value ) for out in [out1, out2]: np.testing.assert_allclose(out.numpy(), paddle_probs_ref, rtol=1e-6) for out in [out3, out4]: np.testing.assert_allclose( out.numpy(), self._take_torch_last_dim(logits_ref), rtol=1e-6, ) np.testing.assert_allclose( out5.numpy(), self._take_torch_last_dim(logits_ref), rtol=1e-6 ) np.testing.assert_allclose(dist1.probs.numpy(), probs_ref, rtol=1e-6) np.testing.assert_allclose( dist1.logits.numpy(), np.log(probs_ref), rtol=1e-6 ) np.testing.assert_allclose( dist3.probs.numpy(), np.exp(logits_ref), rtol=1e-6 ) np.testing.assert_allclose( dist3.entropy().numpy(), -(logits_ref * np.exp(logits_ref)).sum(-1), rtol=1e-6, ) np.testing.assert_allclose(out6.numpy(), zero_log_prob_ref, rtol=1e-6) np.testing.assert_allclose( dist6.logits.numpy(), zero_logits_ref, rtol=1e-6 ) np.testing.assert_allclose( dist6.entropy().numpy(), -(zero_logits_ref * zero_probs_ref).sum(-1), rtol=1e-6, ) self.assertEqual(tuple(dist1.param_shape), self.np_probs.shape) self.assertTrue(np.isnan(dist1.mean.numpy()).all()) self.assertTrue(np.isnan(dist1.variance.numpy()).all()) np.testing.assert_array_equal(dist3.mode.numpy(), np.array([2, 0])) np.testing.assert_array_equal( dist1.support.check(value).numpy(), np.array([True, True]) ) self.assertFalse(dist3._validate_args_enabled) self.assertFalse(dist4._validate_args_enabled) self.assertEqual(list(dist1.sample([2]).shape), [2, 2]) self.assertEqual(list(dist1.sample(np.array([3])).shape), [3, 2]) self.assertEqual( categorical.Categorical(paddle.to_tensor([0.4, 0.6])).batch_shape, (), ) expanded = categorical.Categorical( logits=paddle.to_tensor([0.1, 0.2, 0.7], place=self.place) ) _ = expanded.probs expanded = expanded.expand((4,)) self.assertEqual(expanded.batch_shape, (4,)) self.assertEqual(tuple(expanded.param_shape), (4, 3)) np.testing.assert_allclose( expanded.probs.numpy(), np.tile([[0.25462854, 0.28140804, 0.46396342]], (4, 1)), rtol=1e-6, ) def test_dygraph_Error(self): import importlib categorical = importlib.import_module( "paddle.compat.distributions.categorical" ) paddle.disable_static() probs = paddle.to_tensor(self.np_probs, place=self.place) logits = paddle.to_tensor(self.np_logits, place=self.place) with self.assertRaises(ValueError): categorical.Categorical() with self.assertRaises(ValueError): categorical.Categorical(probs=probs, logits=logits) with self.assertRaises(ValueError): categorical.Categorical(paddle.to_tensor(1.0)) with self.assertRaises(ValueError): categorical.Categorical(logits=paddle.to_tensor(1.0)) def test_dygraph_validate_args(self): import importlib categorical = importlib.import_module( "paddle.compat.distributions.categorical" ) paddle.disable_static() probs = paddle.to_tensor([0.2, 0.3, 0.5], place=self.place) dist = categorical.Categorical(probs=probs, validate_args=True) batched_dist = categorical.Categorical( probs=paddle.to_tensor(self.np_probs, place=self.place), validate_args=True, ) dist.log_prob(paddle.to_tensor([0, 2], place=self.place)) with self.assertRaises(ValueError): dist.log_prob(paddle.to_tensor([3], place=self.place)) with self.assertRaises(ValueError): dist.log_prob( paddle.to_tensor([1.5], dtype="float32", place=self.place) ) with self.assertRaises(ValueError): batched_dist.log_prob(paddle.to_tensor([0, 1, 2], place=self.place)) def test_dygraph_enumerate_support(self): import importlib categorical = importlib.import_module( "paddle.compat.distributions.categorical" ) paddle.disable_static() probs = paddle.to_tensor(self.np_probs, place=self.place) dist = categorical.Categorical(probs=probs) es = dist.enumerate_support() es0 = dist.enumerate_support(expand=False) support = dist.support self.assertEqual(list(es.shape), [3, 2]) self.assertEqual(list(es0.shape), [3, 1]) np.testing.assert_array_equal( es.numpy(), np.array([[0, 0], [1, 1], [2, 2]], dtype="int64") ) np.testing.assert_array_equal( es0.numpy(), np.array([[0], [1], [2]], dtype="int64") ) np.testing.assert_array_equal( support.check(paddle.to_tensor([0, 2], place=self.place)).numpy(), np.array([True, True]), ) np.testing.assert_array_equal( support.check( paddle.to_tensor( [-1, 1.5, 3], dtype="float32", place=self.place ) ).numpy(), np.array([False, False, False]), ) def test_static_Compatibility(self): import importlib categorical = importlib.import_module( "paddle.compat.distributions.categorical" ) paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): probs = paddle.static.data( name="probs", shape=self.np_probs.shape, dtype="float32" ) logits = paddle.static.data( name="logits", shape=self.np_logits.shape, dtype="float32" ) zero_probs = paddle.static.data( name="zero_probs", shape=self.np_zero_probs.shape, dtype="float32", ) value = paddle.static.data( name="value", shape=self.np_value.shape, dtype="int64" ) zero_value = paddle.static.data( name="zero_value", shape=self.np_zero_value.shape, dtype="int64", ) # 1. PyTorch Positional arguments dist1 = categorical.Categorical(probs) out1 = dist1.log_prob(value) # 2. PyTorch keyword arguments dist2 = categorical.Categorical(probs=probs) out2 = dist2.log_prob(value) # 3. PyTorch Positional arguments dist3 = categorical.Categorical(None, logits, False) out3 = dist3.log_prob(value) # 4. PyTorch keyword arguments dist4 = categorical.Categorical( probs=None, logits=logits, validate_args=False ) out4 = dist4.log_prob(value) # 5. Mixed arguments dist5 = categorical.Categorical(None, logits=logits) out5 = dist5.log_prob(value) dist6 = categorical.Categorical(probs=zero_probs) out6 = dist6.log_prob(zero_value) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "probs": self.np_probs, "logits": self.np_logits, "zero_probs": self.np_zero_probs, "value": self.np_value, "zero_value": self.np_zero_value, }, fetch_list=[ out1, out2, out3, out4, out5, out6, dist1.probs, dist1.logits, dist3.probs, dist3.entropy(), dist3.mode, dist1.mean, dist1.variance, dist1.support.check(value), dist6.logits, dist6.entropy(), ], ) probs_ref = self.np_probs / self.np_probs.sum(-1, keepdims=True) logits_ref = self.np_logits - self._logsumexp(self.np_logits) zero_probs_ref = self.np_zero_probs / self.np_zero_probs.sum( -1, keepdims=True ) paddle_probs_ref = self._take_torch_last_dim(np.log(probs_ref)) eps = np.finfo(self.np_zero_probs.dtype).eps zero_logits_ref = np.log(np.clip(zero_probs_ref, eps, 1 - eps)) zero_log_prob_ref = self._take_torch_last_dim( zero_logits_ref, self.np_zero_value ) for out in fetches[:2]: np.testing.assert_allclose(out, paddle_probs_ref, rtol=1e-6) for out in fetches[2:4]: np.testing.assert_allclose( out, self._take_torch_last_dim(logits_ref), rtol=1e-6 ) np.testing.assert_allclose( fetches[4], self._take_torch_last_dim(logits_ref), rtol=1e-6 ) np.testing.assert_allclose(fetches[5], zero_log_prob_ref, rtol=1e-6) np.testing.assert_allclose(fetches[6], probs_ref, rtol=1e-6) np.testing.assert_allclose(fetches[7], np.log(probs_ref), rtol=1e-6) np.testing.assert_allclose(fetches[8], np.exp(logits_ref), rtol=1e-6) np.testing.assert_allclose( fetches[9], -(logits_ref * np.exp(logits_ref)).sum(-1), rtol=1e-6 ) np.testing.assert_array_equal(fetches[10], np.array([2, 0])) self.assertTrue(np.isnan(fetches[11]).all()) self.assertTrue(np.isnan(fetches[12]).all()) np.testing.assert_array_equal(fetches[13], np.array([True, True])) np.testing.assert_allclose(fetches[14], zero_logits_ref, rtol=1e-6) np.testing.assert_allclose( fetches[15], -(zero_logits_ref * zero_probs_ref).sum(-1), rtol=1e-6 ) def test_paddle_api_BackwardCompatibility(self): import importlib categorical = importlib.import_module("paddle.distribution.categorical") paddle.disable_static() logits = paddle.to_tensor(self.np_probs, place=self.place) value = paddle.to_tensor(self.np_value, place=self.place) # 1. Paddle Positional arguments dist1 = categorical.Categorical(logits) out1 = dist1.log_prob(value) # 2. Paddle keyword arguments dist2 = categorical.Categorical(logits=logits) out2 = dist2.log_prob(value) probs_ref = self.np_probs / self.np_probs.sum(-1, keepdims=True) ref_out = np.log( np.take_along_axis( probs_ref, self.np_value.reshape([1, -1]), axis=-1 ) ) for out in [out1, out2]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): logits = paddle.static.data( name="paddle_logits", shape=self.np_probs.shape, dtype="float32", ) value = paddle.static.data( name="paddle_value", shape=self.np_value.shape, dtype="int64" ) # 1. Paddle Positional arguments out3 = categorical.Categorical(logits).log_prob(value) # 2. Paddle keyword arguments out4 = categorical.Categorical(logits=logits).log_prob(value) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "paddle_logits": self.np_probs, "paddle_value": self.np_value, }, fetch_list=[out3, out4], ) for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-6) class TestDistributionsPositiveDefiniteCheckAPI(unittest.TestCase): def setUp(self): self.place = paddle.CPUPlace() self.np_x = np.array([[2.0, 0.5], [0.5, 1.0]], dtype="float32") self.np_not_positive = np.array( [[1.0, 2.0], [2.0, 1.0]], dtype="float32" ) self.np_non_symmetric = np.array( [[1.0, 2.0], [0.0, 1.0]], dtype="float32" ) self.np_not_square = np.ones([2, 3], dtype="float32") self.np_vector = np.ones([2], dtype="float32") def tearDown(self): paddle.enable_static() def test_dygraph_Compatibility(self): from paddle.distribution import constraints paddle.disable_static() x = paddle.to_tensor(self.np_x, place=self.place) not_positive = paddle.to_tensor(self.np_not_positive, place=self.place) not_square = paddle.to_tensor(self.np_not_square, place=self.place) vector = paddle.to_tensor(self.np_vector, place=self.place) self.assertIs(paddle.distribution.constraints, constraints) # 1. Paddle Positional arguments out1 = paddle.distribution.constraint.positive_definite.check(x) # 2. Paddle keyword arguments out2 = paddle.distribution.constraint.positive_definite.check(value=x) # 3. PyTorch Positional arguments out3 = constraints.positive_definite.check(x) # 4. PyTorch keyword arguments out4 = constraints.positive_definite.check(value=x) out5 = constraints.positive_definite.check(not_positive) out6 = constraints.positive_definite.check(not_square) out7 = constraints.positive_definite.check(vector) for out in [out1, out2, out3, out4]: np.testing.assert_array_equal(out.numpy(), np.array(True)) for out in [out5, out6, out7]: np.testing.assert_array_equal(out.numpy(), np.array(False)) def test_static_Compatibility(self): from paddle.distribution import constraints 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="float32" ) not_positive = paddle.static.data( name="not_positive", shape=self.np_not_positive.shape, dtype="float32", ) not_square = paddle.static.data( name="not_square", shape=self.np_not_square.shape, dtype="float32", ) vector = paddle.static.data( name="vector", shape=self.np_vector.shape, dtype="float32" ) # 1. PyTorch Positional arguments out1 = constraints.positive_definite.check(x) # 2. PyTorch keyword arguments out2 = constraints.positive_definite.check(value=x) # 3. PyTorch Positional arguments out3 = constraints.positive_definite.check(not_positive) # 4. PyTorch Positional arguments out4 = constraints.positive_definite.check(not_square) # 5. PyTorch Positional arguments out5 = constraints.positive_definite.check(vector) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "x": self.np_x, "not_positive": self.np_not_positive, "not_square": self.np_not_square, "vector": self.np_vector, }, fetch_list=[out1, out2, out3, out4, out5], ) for out in fetches[:2]: np.testing.assert_array_equal(out, np.array(True)) for out in fetches[2:]: np.testing.assert_array_equal(out, np.array(False)) def test_symmetric_low_rank_returns_false(self): from paddle.distribution import constraint paddle.disable_static() out = constraint.symmetric.check(paddle.ones([2])) self.assertFalse(bool(out)) symmetric_matrix = paddle.to_tensor( [[1.0, 2.0], [2.0, 1.0]], place=self.place ) self.assertTrue(bool(constraint.symmetric.check(symmetric_matrix))) non_symmetric_matrix = paddle.to_tensor( self.np_non_symmetric, place=self.place ) self.assertFalse(bool(constraint.symmetric.check(non_symmetric_matrix))) def test_static_symmetric_low_rank_returns_false(self): from paddle.distribution import constraints paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): vector = paddle.static.data( name="vector", shape=self.np_vector.shape, dtype="float32" ) symmetric_matrix = paddle.static.data( name="symmetric_matrix", shape=self.np_x.shape, dtype="float32" ) non_symmetric_matrix = paddle.static.data( name="non_symmetric_matrix", shape=self.np_non_symmetric.shape, dtype="float32", ) out1 = constraints.symmetric.check(vector) out2 = constraints.symmetric.check(symmetric_matrix) out3 = constraints.symmetric.check(non_symmetric_matrix) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "vector": self.np_vector, "symmetric_matrix": self.np_x, "non_symmetric_matrix": self.np_non_symmetric, }, fetch_list=[out1, out2, out3], ) np.testing.assert_array_equal(fetches[0], np.array(False)) np.testing.assert_array_equal(fetches[1], np.array(True)) np.testing.assert_array_equal(fetches[2], np.array(False)) # Test mv compatibility @unittest.skipIf( paddle.is_compiled_with_custom_device('iluvatar_gpu'), "skip iluvatar_gpu which not register mv kernel", ) class TestMvAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(3, 4).astype("float32") self.np_vec = np.random.rand(4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) vec = paddle.to_tensor(self.np_vec) # 1. Paddle Positional arguments out1 = paddle.mv(x, vec) # 2. Paddle keyword arguments out2 = paddle.mv(x=x, vec=vec) # 3. PyTorch keyword arguments (alias) out3 = paddle.mv(input=x, vec=vec) # 4. Mixed arguments out4 = paddle.mv(x, vec=vec) # 5-6. out parameter test out5 = paddle.zeros([3], dtype="float32") out6 = paddle.mv(x, vec, out=out5) # 7. Tensor method - args out7 = x.mv(vec) # 8. Tensor method - kwargs (PyTorch alias) out8 = x.mv(vec=vec) # Verify all outputs ref_out = np.dot(self.np_x, self.np_vec) for out in [out1, out2, out3, out4, out5, out6, out7, out8]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-5) self.assertEqual(out.shape, (3,)) 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) ) vec = paddle.static.data( name="vec", shape=self.np_vec.shape, dtype=str(self.np_vec.dtype), ) # 1. Paddle Positional arguments out1 = paddle.mv(x, vec) # 2. Paddle keyword arguments out2 = paddle.mv(x=x, vec=vec) # 3. PyTorch keyword arguments (alias) out3 = paddle.mv(input=x, vec=vec) # 4. Tensor method - args out4 = x.mv(vec) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.mv(vec=vec) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "vec": self.np_vec}, fetch_list=[out1, out2, out3, out4, out5], ) # Verify all outputs ref_out = np.dot(self.np_x, self.np_vec) for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-5) class TestDiagflatAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([1, 2, 3]).astype('int64') def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.diagflat(x) # 2. Paddle keyword arguments out2 = paddle.diagflat(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.diagflat(input=x) # 4. Mixed arguments out4 = paddle.diagflat(x, offset=0) # 5. Tensor method - args out5 = x.diagflat() # 6. Tensor method - kwargs (PyTorch alias) out6 = x.diagflat() # Verify all outputs expected_diag = np.diag(self.np_x) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(out.numpy(), expected_diag) 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.diagflat(x) # 2. Paddle keyword arguments out2 = paddle.diagflat(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.diagflat(input=x) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected_diag = np.diag(self.np_x) for out in fetches: np.testing.assert_array_equal(out, expected_diag) @unittest.skipIf( paddle.is_compiled_with_custom_device('iluvatar_gpu'), "skip iluvatar_gpu which not register fill_diagonal_tensor kernel", ) class TestDiagonalScatterAPI(unittest.TestCase): def setUp(self): self.np_x = np.arange(6.0).reshape((2, 3)) self.np_y = np.ones((2,)) 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.diagonal_scatter(x, y) # 2. Paddle keyword arguments out2 = paddle.diagonal_scatter(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.diagonal_scatter(input=x, src=y) # 4. Mixed arguments with dim1/dim2 aliases out4 = paddle.diagonal_scatter(x, y, dim1=0, dim2=1) # 5. Tensor method - args out5 = x.diagonal_scatter(y) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.diagonal_scatter(src=y) # Verify all outputs expected = np.array([[1.0, 1.0, 2.0], [3.0, 1.0, 5.0]]) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), expected) 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) ) y = paddle.static.data( name="y", shape=self.np_y.shape, dtype=str(self.np_y.dtype) ) # 1. Paddle Positional arguments out1 = paddle.diagonal_scatter(x, y) # 2. Paddle keyword arguments out2 = paddle.diagonal_scatter(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.diagonal_scatter(input=x, src=y) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "y": self.np_y}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = np.array([[1.0, 1.0, 2.0], [3.0, 1.0, 5.0]]) for out in fetches: np.testing.assert_allclose(out, expected) class TestLdexpAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([1, 2, 3], dtype='float32') self.np_y = np.array([2, 3, 4], dtype='int32') def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) y = paddle.to_tensor(self.np_y) # 1. Paddle Positional arguments out1 = paddle.ldexp(x, y) # 2. Paddle keyword arguments out2 = paddle.ldexp(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.ldexp(input=x, other=y) # 4. Mixed arguments out4 = paddle.ldexp(x, y=y) # 5-6. out parameter test out5 = paddle.empty_like(x) out6 = paddle.ldexp(x, y, out=out5) assert out5 is out6 # 7. Tensor method - args out7 = x.ldexp(y) # 8. Tensor method - kwargs (PyTorch alias) out8 = x.ldexp(other=y) # Verify all outputs expected = np.array([4.0, 16.0, 48.0], dtype='float32') for out in [out1, out2, out3, out4, out5, out6, out7, out8]: np.testing.assert_allclose(out.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) y = paddle.static.data( name="y", shape=self.np_y.shape, dtype=str(self.np_y.dtype) ) # 1. Paddle Positional arguments out1 = paddle.ldexp(x, y) # 2. Paddle keyword arguments out2 = paddle.ldexp(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.ldexp(input=x, other=y) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "y": self.np_y}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = np.array([4.0, 16.0, 48.0], dtype='float32') for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) # Test inner compatibility class TestInnerAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([1.0, 2.0, 3.0, 4.0]) self.np_y = np.array([5.0, 6.0, 7.0, 8.0]) 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.inner(x, y) # 2. Paddle keyword arguments out2 = paddle.inner(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.inner(input=x, other=y) # 4. Mixed arguments out4 = paddle.inner(x, other=y) # 5-6. out parameter test out5 = paddle.empty_like(out1) out6 = paddle.inner(x, y, out=out5) assert out5 is out6 # 7. Tensor method - args out7 = x.inner(y) # 8. Tensor method - kwargs (PyTorch alias) out8 = x.inner(other=y) # Verify all outputs expected = np.dot(self.np_x, self.np_y) for out in [out1, out2, out3, out4, out5, out6, out7, out8]: np.testing.assert_allclose(out.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) ) y = paddle.static.data( name="y", shape=self.np_y.shape, dtype=str(self.np_y.dtype) ) # 1. Paddle Positional arguments out1 = paddle.inner(x, y) # 2. Paddle keyword arguments out2 = paddle.inner(x=x, y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.inner(input=x, other=y) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "y": self.np_y}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = np.dot(self.np_x, self.np_y) for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-6) # Test positive compatibility class TestPositiveAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-1, 0, 1], dtype='int64') def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.positive(x) # 2. Paddle keyword arguments out2 = paddle.positive(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.positive(input=x) # Verify all outputs expected = self.np_x for out in [out1, out2, out3]: np.testing.assert_allclose(out.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.positive(x) # 2. Paddle keyword arguments out2 = paddle.positive(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.positive(input=x) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = self.np_x for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) # Test rad2deg compatibility class TestRad2degAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([3.142, -3.142, 6.283, -6.283], dtype='float32') def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.rad2deg(x) # 2. Paddle keyword arguments out2 = paddle.rad2deg(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.rad2deg(input=x) # 4-5. out parameter test out4 = paddle.empty_like(x) out5 = paddle.rad2deg(x, out=out4) # 6. Tensor method out6 = x.rad2deg() # Verify all outputs expected = 180.0 / np.pi * self.np_x for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.rad2deg(x) # 2. Paddle keyword arguments out2 = paddle.rad2deg(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.rad2deg(input=x) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = 180.0 / np.pi * self.np_x for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) # Test rot90 compatibility class TestRot90API(unittest.TestCase): def setUp(self): self.np_x = np.arange(4, dtype='float32').reshape(2, 2) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.rot90(x, 1, [0, 1]) # 2. Paddle keyword arguments out2 = paddle.rot90(x=x, k=1, axes=[0, 1]) # 3. PyTorch keyword arguments (alias) out3 = paddle.rot90(input=x, k=1, dims=[0, 1]) # 4. Mixed arguments out4 = paddle.rot90(x, k=1, dims=[0, 1]) # 5. Tensor method - args out5 = x.rot90(1, [0, 1]) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.rot90(k=1, dims=[0, 1]) # Verify all outputs expected = np.array([[1.0, 3.0], [0.0, 2.0]], dtype='float32') for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.rot90(x, 1, [0, 1]) # 2. Paddle keyword arguments out2 = paddle.rot90(x=x, k=1, axes=[0, 1]) # 3. PyTorch keyword arguments (alias) out3 = paddle.rot90(input=x, k=1, dims=[0, 1]) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = np.array([[1.0, 3.0], [0.0, 2.0]], dtype='float32') for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) # Test nanquantile compatibility class TestNanquantileAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(2, 5).astype("float32") self.np_x[0, 0] = np.nan def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.nanquantile(x, 0.5, 0) # 2. Paddle keyword arguments out2 = paddle.nanquantile(x=x, q=0.5, axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.nanquantile(input=x, q=0.5, dim=0) # 4. Mixed arguments out4 = paddle.nanquantile(x, 0.5, dim=0) # 5-6. out parameter test out5 = paddle.empty_like(out1) out6 = paddle.nanquantile(x, 0.5, axis=0, out=out5) assert out5 is out6 # 7. Tensor method - args out7 = x.nanquantile(0.5, 0) # 8. Tensor method - kwargs (PyTorch alias) out8 = x.nanquantile(q=0.5, dim=0) # Verify all outputs for out in [out1, out2, out3, out4, out5, out6, out7, out8]: 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.nanquantile(x, 0.5, 0) # 2. Paddle keyword arguments out2 = paddle.nanquantile(x=x, q=0.5, axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.nanquantile(input=x, q=0.5, dim=0) # 4. Tensor method - args out4 = x.nanquantile(0.5, 0) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.nanquantile(q=0.5, dim=0) 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: np.testing.assert_allclose(out, fetches[0], rtol=1e-5) # Test neg compatibility class TestNegAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.4, -0.2, 0.1, 0.3], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.neg(x) # 2. Paddle keyword arguments out2 = paddle.neg(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.neg(input=x) # 4-5. out parameter test out4 = paddle.empty_like(out1) out5 = paddle.neg(x, out=out4) assert out4 is out5 # 6. Tensor method out6 = x.neg() # Verify all outputs expected = -self.np_x for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), expected, 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.neg(x) # 2. Paddle keyword arguments out2 = paddle.neg(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.neg(input=x) # 4. Tensor method out4 = x.neg() exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3, out4], ) # Verify all outputs expected = -self.np_x for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) # Test randint compatibility class TestRandintAPI(unittest.TestCase): def test_dygraph_Compatibility(self): paddle.disable_static() # basic shape x = paddle.randint(high=10, shape=[2, 3]) self.assertEqual(x.shape, [2, 3]) self.assertTrue(x.stop_gradient) # 'size' is an alias for 'shape' x = paddle.randint(high=10, size=[3, 4]) self.assertEqual(x.shape, [3, 4]) # requires_grad x = paddle.randint(high=10, shape=[2, 3], requires_grad=True) self.assertFalse(x.stop_gradient) x = paddle.randint(high=10, shape=[2, 3], requires_grad=False) self.assertTrue(x.stop_gradient) # value range x = paddle.randint(low=5, high=10, shape=[100]) arr = x.numpy() self.assertTrue(np.all(arr >= 5) and np.all(arr < 10)) # torch.randint(high, size) style: second positional arg as shape x = paddle.randint(10, [3, 4]) self.assertEqual(x.shape, [3, 4]) self.assertTrue(np.all(x.numpy() >= 0) and np.all(x.numpy() < 10)) # dtype string x = paddle.randint(high=10, shape=[3], dtype='int32') self.assertEqual(x.dtype, paddle.int32) # out param out = paddle.zeros([2, 3], dtype='int64') result = paddle.randint(high=10, shape=[2, 3], out=out) self.assertEqual(out.shape, [2, 3]) np.testing.assert_array_equal(result.numpy(), out.numpy()) # out with requires_grad out = paddle.zeros([2, 3], dtype='int64') result = paddle.randint( high=10, shape=[2, 3], out=out, requires_grad=True ) self.assertFalse(result.stop_gradient) paddle.enable_static() def test_static_Compatibility(self): # basic shape and stop_gradient main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.randint(high=10, shape=[2, 3]) self.assertEqual(x.shape, [2, 3]) self.assertTrue(x.stop_gradient) # requires_grad x_grad = paddle.randint(high=10, shape=[2, 3], requires_grad=True) self.assertFalse(x_grad.stop_gradient) x_no_grad = paddle.randint( high=10, shape=[2, 3], requires_grad=False ) self.assertTrue(x_no_grad.stop_gradient) # size alias x_size = paddle.randint(high=10, size=[2, 3]) self.assertEqual(x_size.shape, [2, 3]) # dtype string x_dtype = paddle.randint(high=10, shape=[3], dtype='int32') exe = paddle.static.Executor(paddle.CPUPlace()) exe.run(startup) result = exe.run(main, fetch_list=[x_dtype]) self.assertEqual(result[0].dtype, np.int32) # Test remainder_ inplace compatibility class TestRemainderInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.randint(1, 20, [5, 6]).astype("int64") self.np_y = np.random.randint(1, 10, [5, 6]).astype("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.remainder_(x.clone(), y) # 2. Paddle keyword arguments out2 = paddle.remainder_(x=x.clone(), y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.remainder_(input=x.clone(), other=y) # 4. Mixed arguments out4 = paddle.remainder_(x.clone(), y=y) # 5. Tensor method - args out5 = x.clone().remainder_(y) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().remainder_(other=y) # Verify all outputs ref_out = np.mod(self.np_x, self.np_y) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(ref_out, out.numpy()) # Test remainder_ inplace compatibility class TestModInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.randint(1, 20, [5, 6]).astype("int64") self.np_y = np.random.randint(1, 10, [5, 6]).astype("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.mod_(x.clone(), y) # 2. Paddle keyword arguments out2 = paddle.mod_(x=x.clone(), y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.floor_mod_(input=x.clone(), other=y) # 4. Mixed arguments out4 = paddle.floor_mod_(x.clone(), y=y) # 5. Tensor method - args out5 = x.clone().mod_(y) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().floor_mod_(other=y) # Verify all outputs ref_out = np.mod(self.np_x, self.np_y) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(ref_out, out.numpy()) # Test squeeze compatibility class TestSqueezeAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(1, 3, 1, 5).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments (axis=None) out1 = paddle.squeeze(x) # 2. Paddle Positional arguments (axis=int) out2 = paddle.squeeze(x, 0) # 3. Paddle keyword arguments out3 = paddle.squeeze(x=x, axis=0) # 4. PyTorch keyword arguments (alias) out4 = paddle.squeeze(input=x, dim=0) # 5. Mixed arguments out5 = paddle.squeeze(x, axis=0) # 6. Tensor method - args out6 = x.squeeze(0) # 7. Tensor method - kwargs (PyTorch alias) out7 = x.squeeze(dim=0) ref_out_none = np.squeeze(self.np_x) np.testing.assert_allclose(out1.numpy(), ref_out_none) # Verify all outputs ref_out = np.squeeze(self.np_x, axis=0) for out in [out2, out3, out4, out5, out6, out7]: np.testing.assert_allclose(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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.squeeze(x, 0) # 2. Paddle keyword arguments out2 = paddle.squeeze(x=x, axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.squeeze(input=x, dim=0) # 4. Tensor method - args out4 = x.squeeze(0) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.squeeze(dim=0) 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.squeeze(self.np_x, axis=0) for out in fetches: np.testing.assert_allclose(out, ref_out) # Test squeeze_ inplace compatibility class TestSqueezeInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(1, 3, 1, 5).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.squeeze_(x.clone(), 0) # 2. Paddle keyword arguments out2 = paddle.squeeze_(x=x.clone(), axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.squeeze_(input=x.clone(), dim=0) # 4. Mixed arguments out4 = paddle.squeeze_(x.clone(), axis=0) # 5. Tensor method - args out5 = x.clone().squeeze_(0) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().squeeze_(dim=0) # Verify all outputs ref_out = np.squeeze(self.np_x, axis=0) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), ref_out) # Test unsqueeze compatibility class TestUnsqueezeAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(5, 10).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.unsqueeze(x, 0) # 2. Paddle keyword arguments out2 = paddle.unsqueeze(x=x, axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.unsqueeze(input=x, dim=0) # 4. Mixed arguments out4 = paddle.unsqueeze(x, axis=0) # 5. Tensor method - args out5 = x.unsqueeze(0) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.unsqueeze(dim=0) # Verify all outputs ref_out = np.expand_dims(self.np_x, axis=0) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.unsqueeze(x, 0) # 2. Paddle keyword arguments out2 = paddle.unsqueeze(x=x, axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.unsqueeze(input=x, dim=0) # 4. Tensor method - args out4 = x.unsqueeze(0) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.unsqueeze(dim=0) 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.expand_dims(self.np_x, axis=0) for out in fetches: np.testing.assert_allclose(out, ref_out) # Test unsqueeze_ inplace compatibility class TestUnsqueezeInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(5, 10).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.unsqueeze_(x.clone(), 0) # 2. Paddle keyword arguments out2 = paddle.unsqueeze_(x=x.clone(), axis=0) # 3. PyTorch keyword arguments (alias) out3 = paddle.unsqueeze_(input=x.clone(), dim=0) # 4. Mixed arguments out4 = paddle.unsqueeze_(x.clone(), axis=0) # 5. Tensor method - args out5 = x.clone().unsqueeze_(0) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().unsqueeze_(dim=0) # Verify all outputs ref_out = np.expand_dims(self.np_x, axis=0) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), ref_out) # Test pow_ inplace compatibility class TestPowInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(5, 6).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) y_scalar = 2.0 # 1. Paddle Positional arguments out1 = paddle.pow_(x.clone(), y_scalar) # 2. Paddle keyword arguments out2 = paddle.pow_(x=x.clone(), y=y_scalar) # 3. PyTorch keyword arguments (alias) out3 = paddle.pow_(input=x.clone(), exponent=y_scalar) # 4. Mixed arguments out4 = paddle.pow_(x.clone(), y=y_scalar) # 5. Tensor method - args out5 = x.clone().pow_(y_scalar) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().pow_(exponent=y_scalar) # Verify all outputs ref_out = np.power(self.np_x, y_scalar) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-5) # Test floor_divide_ inplace compatibility class TestFloorDivideInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.randint(10, 100, [5, 6]).astype("int64") self.np_y = np.random.randint(1, 10, [5, 6]).astype("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.floor_divide_(x.clone(), y) # 2. Paddle keyword arguments out2 = paddle.floor_divide_(x=x.clone(), y=y) # 3. PyTorch keyword arguments (alias) out3 = paddle.floor_divide_(input=x.clone(), other=y) # 4. Mixed arguments out4 = paddle.floor_divide_(x.clone(), y=y) # 5. Tensor method - args out5 = x.clone().floor_divide_(y) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.clone().floor_divide_(other=y) # Verify all outputs ref_out = np.floor_divide(self.np_x, self.np_y) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(out.numpy(), ref_out) # Test isposinf compatibility class TestIsposinfAPICompatibility(unittest.TestCase): def setUp(self): self.np_x = np.array( [[1.0, np.inf, -np.inf], [0.0, -1.0, np.inf]] ).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.isposinf(x) # 2. Paddle keyword arguments out2 = paddle.isposinf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isposinf(input=x) # 4-5. out parameter test out4 = paddle.zeros_like(out1) out5 = paddle.isposinf(x, out=out4) self.assertIs(out4, out5) # 6. Tensor method out6 = x.isposinf() # Verify all outputs ref_out = np.isposinf(self.np_x) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(ref_out, out.numpy()) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data( name="x", shape=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.isposinf(x) # 2. Paddle keyword arguments out2 = paddle.isposinf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isposinf(input=x) # 4. Tensor method - args out4 = x.isposinf() exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3, out4], ) # Verify all outputs ref_out = np.isposinf(self.np_x) for out in fetches: np.testing.assert_array_equal(ref_out, out) # Test isneginf compatibility class TestIsneginfAPICompatibility(unittest.TestCase): def setUp(self): self.np_x = np.array( [[1.0, np.inf, -np.inf], [0.0, -1.0, np.inf]] ).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.isneginf(x) # 2. Paddle keyword arguments out2 = paddle.isneginf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isneginf(input=x) # 4-5. out parameter test out4 = paddle.zeros_like(out1) out5 = paddle.isneginf(x, out=out4) assert out4 is out5 # 6. Tensor method out6 = x.isneginf() # Verify all outputs ref_out = np.isneginf(self.np_x) for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_array_equal(ref_out, out.numpy()) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data( name="x", shape=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.isneginf(x) # 2. Paddle keyword arguments out2 = paddle.isneginf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isneginf(input=x) # 4. Tensor method - args out4 = x.isneginf() exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3, out4], ) # Verify all outputs ref_out = np.isneginf(self.np_x) for out in fetches: np.testing.assert_array_equal(ref_out, out) # Test isreal compatibility class TestIsRealAPICompatibility(unittest.TestCase): def setUp(self): self.np_x = np.array( [[1.0 + 0j, 2.0 + 3j], [4.0 + 0j, 5.0 - 6j]] ).astype("complex64") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.isreal(x) # 2. Paddle keyword arguments out2 = paddle.isreal(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isreal(input=x) # 4. Tensor method - args out4 = x.isreal() # Verify all outputs ref_out = np.isreal(self.np_x) for out in [out1, out2, out3, out4]: 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.isreal(x) # 2. Paddle keyword arguments out2 = paddle.isreal(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.isreal(input=x) # 4. Tensor method - args out4 = x.isreal() exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3, out4], ) # Verify all outputs ref_out = np.isreal(self.np_x) for out in fetches: np.testing.assert_array_equal(ref_out, out) class TestLayerAndTensorToAPI(unittest.TestCase): """Test paddle.nn.Layer.to and paddle.Tensor.to alignment with PyTorch.""" def setUp(self): paddle.disable_static() def tearDown(self): paddle.enable_static() def _make_model(self): """Create a model with float params and an int buffer.""" class Model(paddle.nn.Layer): def __init__(self): super().__init__() self.linear = paddle.nn.Linear(3, 2) self.register_buffer( 'int_buf', paddle.to_tensor([1, 2, 3], dtype='int32') ) def forward(self, x): return self.linear(x) return Model() # ---- Layer.to: Positional dtype ---- def test_layer_positional_paddle_dtype(self): """Layer.to(paddle.float64)""" linear = paddle.nn.Linear(2, 2) ret = linear.to(paddle.float64) self.assertEqual(linear.weight.dtype, paddle.float64) self.assertEqual(linear.bias.dtype, paddle.float64) self.assertIs(ret, linear) def test_layer_positional_dtype_string(self): """Layer.to('float64')""" linear = paddle.nn.Linear(2, 2) linear.to('float64') self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_positional_dtype_float16(self): """Layer.to(paddle.float16)""" linear = paddle.nn.Linear(2, 2) linear.to(paddle.float16) self.assertEqual(linear.weight.dtype, paddle.float16) # ---- Layer.to: Positional tensor ---- def test_layer_positional_tensor(self): """Layer.to(tensor) -- match tensor's dtype and device""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(ref) self.assertEqual(linear.weight.dtype, paddle.float64) # ---- Layer.to: Positional device ---- def test_layer_positional_device_string(self): """Layer.to('cpu')""" linear = paddle.nn.Linear(2, 2) linear.to('cpu') self.assertTrue(linear.weight.place.is_cpu_place()) def test_layer_positional_device_and_dtype(self): """Layer.to('cpu', 'float64')""" linear = paddle.nn.Linear(2, 2) linear.to('cpu', 'float64') self.assertTrue(linear.weight.place.is_cpu_place()) self.assertEqual(linear.weight.dtype, paddle.float64) # ---- Layer.to: Keyword args ---- def test_layer_keyword_device(self): """Layer.to(device='cpu')""" linear = paddle.nn.Linear(2, 2) linear.to(device='cpu') self.assertTrue(linear.weight.place.is_cpu_place()) def test_layer_keyword_dtype(self): """Layer.to(dtype='float64')""" linear = paddle.nn.Linear(2, 2) linear.to(dtype='float64') self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_keyword_device_and_dtype(self): """Layer.to(device='cpu', dtype='float64')""" linear = paddle.nn.Linear(2, 2) linear.to(device='cpu', dtype='float64') self.assertTrue(linear.weight.place.is_cpu_place()) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_keyword_non_blocking(self): """Layer.to(dtype='float64', non_blocking=False)""" linear = paddle.nn.Linear(2, 2) linear.to(dtype='float64', non_blocking=False) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_keyword_blocking(self): """Layer.to(device='cpu', blocking=True)""" linear = paddle.nn.Linear(2, 2) linear.to(device='cpu', blocking=True) self.assertTrue(linear.weight.place.is_cpu_place()) # ---- Layer.to: No args ---- def test_layer_no_args(self): """Layer.to() -- returns self unchanged""" linear = paddle.nn.Linear(2, 2) original_dtype = linear.weight.dtype ret = linear.to() self.assertIs(ret, linear) self.assertEqual(linear.weight.dtype, original_dtype) # ---- Layer.to: floating-only dtype casting (PyTorch-aligned) ---- def test_layer_cast_floating_only_with_positional_dtype(self): """Layer.to(dtype) casts only floating/complex params and buffers.""" model = self._make_model() self.assertEqual(model.int_buf.dtype, paddle.int32) model.to(paddle.float64) self.assertEqual(model.linear.weight.dtype, paddle.float64) self.assertEqual(model.int_buf.dtype, paddle.int32) def test_layer_cast_floating_only_with_keyword_dtype(self): """Layer.to(dtype='float64') casts only floating/complex tensors.""" model = self._make_model() model.to(dtype='float64') self.assertEqual(model.linear.weight.dtype, paddle.float64) self.assertEqual(model.int_buf.dtype, paddle.int32) def test_layer_cast_floating_only_with_tensor(self): """Layer.to(tensor) casts only floating/complex tensors to tensor.dtype.""" model = self._make_model() ref = paddle.to_tensor([1.0], dtype='float64') model.to(ref) self.assertEqual(model.linear.weight.dtype, paddle.float64) self.assertEqual(model.int_buf.dtype, paddle.int32) # ---- Layer.to: sublayers and chaining ---- def test_layer_sublayers_cast(self): """Layer.to() should recurse into sublayers.""" model = paddle.nn.Sequential( paddle.nn.Linear(3, 4), paddle.nn.Linear(4, 2) ) model.to(paddle.float64) for sub in model.sublayers(): if hasattr(sub, 'weight'): self.assertEqual(sub.weight.dtype, paddle.float64) def test_layer_returns_self(self): """Layer.to() should return self for chaining.""" linear = paddle.nn.Linear(2, 2) self.assertIs(linear.to(paddle.float64), linear) def test_layer_sequential_to_calls(self): """Multiple Layer.to() calls should work correctly.""" linear = paddle.nn.Linear(2, 2) linear.to(paddle.float64) self.assertEqual(linear.weight.dtype, paddle.float64) linear.to('float32') self.assertEqual(linear.weight.dtype, paddle.float32) # ---- Tensor.to ---- def test_tensor_positional_dtype(self): """Tensor.to(paddle.float64)""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(paddle.float64) self.assertEqual(out.dtype, paddle.float64) def test_tensor_positional_dtype_string(self): """Tensor.to('float64')""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('float64') self.assertEqual(out.dtype, paddle.float64) def test_tensor_positional_device(self): """Tensor.to('cpu')""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('cpu') self.assertTrue(out.place.is_cpu_place()) def test_tensor_positional_device_and_dtype(self): """Tensor.to('cpu', 'float64')""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('cpu', 'float64') self.assertTrue(out.place.is_cpu_place()) self.assertEqual(out.dtype, paddle.float64) def test_tensor_positional_other(self): """Tensor.to(other_tensor)""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(ref) self.assertEqual(out.dtype, paddle.int32) def test_tensor_keyword_dtype(self): """Tensor.to(dtype='float64')""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(dtype='float64') self.assertEqual(out.dtype, paddle.float64) def test_tensor_keyword_device(self): """Tensor.to(device='cpu')""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(device='cpu') self.assertTrue(out.place.is_cpu_place()) def test_tensor_keyword_non_blocking(self): """Tensor.to(dtype='float64', non_blocking=False)""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(dtype='float64', non_blocking=False) self.assertEqual(out.dtype, paddle.float64) def test_tensor_no_args(self): """Tensor.to() -- returns self""" t = paddle.to_tensor([1.0, 2.0]) out = t.to() self.assertEqual(out.dtype, t.dtype) # ---- blocking / non_blocking conflict ---- def test_blocking_non_blocking_conflict_raises(self): """Setting both blocking and non_blocking raises TypeError.""" linear = paddle.nn.Linear(2, 2) with self.assertRaises(TypeError): linear.to(dtype='float64', blocking=True, non_blocking=False) def test_tensor_blocking_non_blocking_conflict_raises(self): """Tensor: setting both blocking and non_blocking raises TypeError.""" t = paddle.to_tensor([1.0]) with self.assertRaises(TypeError): t.to(dtype='float64', blocking=True, non_blocking=False) # ---- Error handling ---- def test_too_many_args(self): """to() with too many arguments raises TypeError.""" linear = paddle.nn.Linear(2, 2) with self.assertRaises(TypeError): linear.to('cpu', 'float64', True, False, 'extra') def test_unexpected_keyword(self): """to() with unexpected keyword raises TypeError.""" linear = paddle.nn.Linear(2, 2) with self.assertRaises(TypeError): linear.to(foo='bar') def test_invalid_first_arg(self): """to() with invalid first arg raises ValueError.""" linear = paddle.nn.Linear(2, 2) with self.assertRaises(ValueError): linear.to(123) # ---- PyTorch keyword alias: other / tensor ---- def test_layer_keyword_other_alias(self): """Layer.to(other=tensor) -- PyTorch alias for tensor overload.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(other=ref) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_keyword_tensor_alias(self): """Layer.to(tensor=tensor) -- PyTorch alias for tensor overload.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(tensor=ref) self.assertEqual(linear.weight.dtype, paddle.float64) def test_tensor_keyword_other_alias(self): """Tensor.to(other=tensor) -- PyTorch alias for tensor overload.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(other=ref) self.assertEqual(out.dtype, paddle.int32) def test_tensor_keyword_tensor_alias(self): """Tensor.to(tensor=tensor) -- PyTorch alias for tensor overload.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(tensor=ref) self.assertEqual(out.dtype, paddle.int32) # ---- copy parameter: Layer.to (tensor overload) ---- def test_layer_tensor_overload_copy_positional(self): """Layer.to(tensor, blocking, copy) -- copy as 3rd positional.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(ref, True, True) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_tensor_overload_copy_keyword(self): """Layer.to(tensor, copy=True) -- copy as keyword.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(ref, copy=True) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_tensor_overload_copy_mixed(self): """Layer.to(tensor, blocking=True, copy=True) -- mixed.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(ref, blocking=True, copy=True) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_tensor_overload_copy_false_keyword(self): """Layer.to(tensor, copy=False) -- explicit copy=False.""" linear = paddle.nn.Linear(2, 2) ref = paddle.to_tensor([1.0], dtype='float64') linear.to(ref, copy=False) self.assertEqual(linear.weight.dtype, paddle.float64) # ---- copy parameter: Layer.to (dtype overload) ---- def test_layer_dtype_overload_copy_positional(self): """Layer.to(dtype, blocking, copy) -- copy as 3rd positional.""" linear = paddle.nn.Linear(2, 2) linear.to('float64', True, True) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_dtype_overload_copy_keyword(self): """Layer.to(dtype, copy=True) -- copy as keyword.""" linear = paddle.nn.Linear(2, 2) linear.to('float64', copy=True) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_dtype_overload_copy_mixed(self): """Layer.to(dtype, blocking=True, copy=True) -- mixed.""" linear = paddle.nn.Linear(2, 2) linear.to(paddle.float64, blocking=True, copy=True) self.assertEqual(linear.weight.dtype, paddle.float64) # ---- copy parameter: Layer.to (device overload) ---- def test_layer_device_overload_copy_positional(self): """Layer.to(device, dtype, blocking, copy) -- copy as 4th positional.""" linear = paddle.nn.Linear(2, 2) linear.to('cpu', 'float64', True, True) self.assertTrue(linear.weight.place.is_cpu_place()) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_device_overload_copy_keyword(self): """Layer.to(device, copy=True) -- copy as keyword only.""" linear = paddle.nn.Linear(2, 2) linear.to('cpu', copy=True) self.assertTrue(linear.weight.place.is_cpu_place()) def test_layer_device_overload_all_kwargs(self): """Layer.to(device=, dtype=, blocking=, copy=) -- all keywords.""" linear = paddle.nn.Linear(2, 2) linear.to(device='cpu', dtype='float64', blocking=True, copy=True) self.assertTrue(linear.weight.place.is_cpu_place()) self.assertEqual(linear.weight.dtype, paddle.float64) def test_layer_device_overload_mixed_copy_keyword(self): """Layer.to(device, dtype, copy=True) -- 2 positional + copy kwarg.""" linear = paddle.nn.Linear(2, 2) linear.to('cpu', 'float64', copy=True) self.assertTrue(linear.weight.place.is_cpu_place()) self.assertEqual(linear.weight.dtype, paddle.float64) # ---- copy parameter: Tensor.to (tensor overload) ---- def test_tensor_tensor_overload_copy_positional(self): """Tensor.to(other, blocking, copy) -- copy as 3rd positional.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(ref, True, True) self.assertEqual(out.dtype, paddle.int32) def test_tensor_tensor_overload_copy_keyword(self): """Tensor.to(other, copy=True) -- copy as keyword.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(ref, copy=True) self.assertEqual(out.dtype, paddle.int32) def test_tensor_tensor_overload_copy_mixed(self): """Tensor.to(other, blocking=True, copy=True) -- mixed.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(ref, blocking=True, copy=True) self.assertEqual(out.dtype, paddle.int32) def test_tensor_tensor_overload_full_kwargs(self): """Tensor.to(other=, blocking=, copy=) -- all keywords.""" t = paddle.to_tensor([1.0, 2.0]) ref = paddle.to_tensor([1], dtype='int32') out = t.to(other=ref, blocking=True, copy=True) self.assertEqual(out.dtype, paddle.int32) # ---- copy parameter: Tensor.to (dtype overload) ---- def test_tensor_dtype_overload_copy_positional(self): """Tensor.to(dtype, blocking, copy) -- copy as 3rd positional.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('float64', True, True) self.assertEqual(out.dtype, paddle.float64) def test_tensor_dtype_overload_copy_keyword(self): """Tensor.to(dtype, copy=True) -- copy as keyword.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('float64', copy=True) self.assertEqual(out.dtype, paddle.float64) def test_tensor_dtype_overload_copy_mixed(self): """Tensor.to(dtype, blocking=True, copy=True) -- mixed.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(paddle.float64, blocking=True, copy=True) self.assertEqual(out.dtype, paddle.float64) # ---- copy parameter: Tensor.to (device overload) ---- def test_tensor_device_overload_copy_positional(self): """Tensor.to(device, dtype, blocking, copy) -- copy as 4th positional.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('cpu', 'float64', True, True) self.assertTrue(out.place.is_cpu_place()) self.assertEqual(out.dtype, paddle.float64) def test_tensor_device_overload_copy_keyword(self): """Tensor.to(device, copy=True) -- copy as keyword only.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('cpu', copy=True) self.assertTrue(out.place.is_cpu_place()) def test_tensor_device_overload_all_kwargs(self): """Tensor.to(device=, dtype=, blocking=, copy=) -- all keywords.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to(device='cpu', dtype='float64', blocking=True, copy=True) self.assertTrue(out.place.is_cpu_place()) self.assertEqual(out.dtype, paddle.float64) def test_tensor_device_overload_mixed_copy_keyword(self): """Tensor.to(device, dtype, copy=True) -- 2 positional + copy kwarg.""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('cpu', 'float64', copy=True) self.assertTrue(out.place.is_cpu_place()) self.assertEqual(out.dtype, paddle.float64) # ---- copy parameter defaults and validation ---- def test_copy_default_is_false_layer(self): """Layer.to without copy should default copy=False (no error).""" linear = paddle.nn.Linear(2, 2) linear.to('float64') self.assertEqual(linear.weight.dtype, paddle.float64) def test_copy_default_is_false_tensor(self): """Tensor.to without copy should default copy=False (no error).""" t = paddle.to_tensor([1.0, 2.0]) out = t.to('float64') self.assertEqual(out.dtype, paddle.float64) def test_copy_invalid_type_layer(self): """Layer.to(dtype, copy='yes') raises TypeError for non-bool.""" linear = paddle.nn.Linear(2, 2) with self.assertRaises(TypeError): linear.to('float64', copy='yes') def test_copy_invalid_type_tensor(self): """Tensor.to(dtype, copy='yes') raises TypeError for non-bool.""" t = paddle.to_tensor([1.0, 2.0]) with self.assertRaises(TypeError): t.to('float64', copy='yes') # Test paddle.dtype.itemsize compatibility (mirrors torch.dtype.itemsize). class TestDtypeItemsizeAPI(unittest.TestCase): EXPECTED = { 'float16': 2, 'bfloat16': 2, 'float32': 4, 'float64': 8, 'complex64': 8, 'complex128': 16, 'int8': 1, 'int16': 2, 'int32': 4, 'int64': 8, 'uint8': 1, 'uint16': 2, 'uint32': 4, 'uint64': 8, 'bool': 1, 'float8_e4m3fn': 1, 'float8_e5m2': 1, } def test_all_standard_dtypes(self): for name, want in self.EXPECTED.items(): if not hasattr(paddle, name): continue with self.subTest(dtype=name): self.assertEqual(getattr(paddle, name).itemsize, want) def test_returns_int(self): self.assertIsInstance(paddle.float32.itemsize, int) def test_dtype_str(self): for name in ('float8_e5m2', 'uint16', 'uint32', 'uint64', 'bfloat16'): with self.subTest(dtype=name): self.assertEqual(str(getattr(paddle, name)), f'paddle.{name}') def test_property_lives_on_class(self): self.assertIsInstance(type(paddle.float32).itemsize, property) def test_aliases_match(self): self.assertEqual(paddle.float.itemsize, paddle.float32.itemsize) self.assertEqual(paddle.double.itemsize, paddle.float64.itemsize) self.assertEqual(paddle.half.itemsize, paddle.float16.itemsize) self.assertEqual(paddle.short.itemsize, paddle.int16.itemsize) self.assertEqual(paddle.long.itemsize, paddle.int64.itemsize) self.assertEqual(paddle.cfloat.itemsize, paddle.complex64.itemsize) self.assertEqual(paddle.cdouble.itemsize, paddle.complex128.itemsize) def test_matches_tensor_element_size(self): for name in ('float32', 'float64', 'int32', 'int64', 'bool'): with self.subTest(dtype=name): t = paddle.zeros([1], dtype=name) self.assertEqual( getattr(paddle, name).itemsize, t.element_size() ) class TestFloat8E5M2DtypeAPI(unittest.TestCase): def check_finfo(self, info): self.assertEqual(info.bits, 8) self.assertEqual(str(info.dtype), 'float8_e5m2') self.assertEqual(info.eps, 0.25) self.assertEqual(info.min, -57344.0) self.assertEqual(info.max, 57344.0) self.assertEqual(info.smallest_normal, 6.103515625e-05) self.assertEqual(info.tiny, 6.103515625e-05) def test_dygraph_Compatibility(self): paddle.disable_static() # 1. Paddle Positional arguments out1 = paddle.finfo(paddle.float8_e5m2) # 2. Paddle keyword arguments out2 = paddle.finfo(dtype=paddle.float8_e5m2) # 3. PyTorch keyword arguments (alias) out3 = paddle.finfo(type=paddle.float8_e5m2) # Verify all outputs for out in [out1, out2, out3]: self.check_finfo(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): # 1. Paddle Positional arguments out1 = paddle.finfo(paddle.float8_e5m2) # 2. Paddle keyword arguments out2 = paddle.finfo(dtype=paddle.float8_e5m2) # 3. PyTorch keyword arguments (alias) out3 = paddle.finfo(type=paddle.float8_e5m2) # Verify all outputs for out in [out1, out2, out3]: self.check_finfo(out) class TestUnsignedDtypeAPI(unittest.TestCase): EXPECTED = { 'uint16': (0, 65535, 16), 'uint32': (0, 4294967295, 32), 'uint64': (0, 18446744073709551615, 64), } def check_iinfo(self, info, name): min_value, max_value, bits = self.EXPECTED[name] self.assertEqual(info.min, min_value) self.assertEqual(info.max, max_value) self.assertEqual(info.bits, bits) self.assertEqual(str(info.dtype), name) self.assertIn(f'max={max_value}', repr(info)) def test_dygraph_Compatibility(self): paddle.disable_static() for name in self.EXPECTED: dtype = getattr(paddle, name) with self.subTest(dtype=name): # 1. Paddle Positional arguments out1 = paddle.iinfo(dtype) # 2. Paddle keyword arguments out2 = paddle.iinfo(dtype=dtype) # 3. PyTorch keyword arguments (alias) out3 = paddle.iinfo(type=dtype) # Verify all outputs for out in [out1, out2, out3]: self.check_iinfo(out, name) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): for name in self.EXPECTED: dtype = getattr(paddle, name) with self.subTest(dtype=name): # 1. Paddle Positional arguments out1 = paddle.iinfo(dtype) # 2. Paddle keyword arguments out2 = paddle.iinfo(dtype=dtype) # 3. PyTorch keyword arguments (alias) out3 = paddle.iinfo(type=dtype) # Verify all outputs for out in [out1, out2, out3]: self.check_iinfo(out, name) # Test select_scatter compatibility class TestSelectScatterAPICompatibility(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(2, 3, 4).astype("float32") self.np_values = np.random.rand(2, 4).astype("float32") self.axis = 1 self.index = 1 def get_ref_out(self): ref_out = self.np_x.copy() ref_out[:, self.index, :] = self.np_values return ref_out def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) values = paddle.to_tensor(self.np_values) # 1. Paddle Positional arguments out1 = paddle.select_scatter(x, values, self.axis, self.index) # 2. Paddle keyword arguments out2 = paddle.select_scatter( x=x, values=values, axis=self.axis, index=self.index ) # 3. PyTorch keyword arguments (alias) out3 = paddle.select_scatter( input=x, src=values, dim=self.axis, index=self.index ) # 4. Mixed arguments out4 = paddle.select_scatter( x, src=values, dim=self.axis, index=self.index ) # 5. Tensor method - args out5 = x.select_scatter(values, self.axis, self.index) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.select_scatter(src=values, dim=self.axis, index=self.index) # Verify all outputs ref_out = self.get_ref_out() 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=self.np_x.shape, dtype=str(self.np_x.dtype) ) values = paddle.static.data( name="values", shape=self.np_values.shape, dtype=str(self.np_values.dtype), ) # 1. Paddle Positional arguments out1 = paddle.select_scatter(x, values, self.axis, self.index) # 2. Paddle keyword arguments out2 = paddle.select_scatter( x=x, values=values, axis=self.axis, index=self.index ) # 3. PyTorch keyword arguments (alias) out3 = paddle.select_scatter( input=x, src=values, dim=self.axis, index=self.index ) # 4. Tensor method - args out4 = x.select_scatter(values, self.axis, self.index) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.select_scatter(src=values, dim=self.axis, index=self.index) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "values": self.np_values}, fetch_list=[out1, out2, out3, out4, out5], ) # Verify all outputs ref_out = self.get_ref_out() for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-5) # Test tile compatibility class TestTileAPICompatibility(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.random.rand(2, 3).astype("float32") self.repeat_times = [2, 3] self.shape = self.np_x.shape self.dtype = str(self.np_x.dtype) self.np_x_3d = np.random.rand(1, 2, 2).astype("float64") self.repeat_times_3d = [2, 1, 3] self.shape_3d = self.np_x_3d.shape self.dtype_3d = str(self.np_x_3d.dtype) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.tile(x, self.repeat_times) # 2. Paddle keyword arguments out2 = paddle.tile(x=x, repeat_times=self.repeat_times) # 3. PyTorch keyword arguments (alias) out3 = paddle.tile(input=x, dims=self.repeat_times) # 4. Mixed arguments out4 = paddle.tile(x, dims=self.repeat_times) # 5. Tensor method - args out5 = x.tile(2, 3) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.tile(dims=self.repeat_times) # Verify all outputs ref_out = np.tile(self.np_x, self.repeat_times) 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=self.shape, dtype=self.dtype) # 1. Paddle Positional arguments out1 = paddle.tile(x, self.repeat_times) # 2. Paddle keyword arguments out2 = paddle.tile(x=x, repeat_times=self.repeat_times) # 3. PyTorch keyword arguments (alias) out3 = paddle.tile(input=x, dims=self.repeat_times) # 4. Tensor method - args out4 = x.tile(2, 3) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.tile(dims=self.repeat_times) 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.tile(self.np_x, self.repeat_times) for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-5) def test_dygraph_HighDimCompatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x_3d) # 1. Paddle Positional arguments out1 = paddle.tile(x, self.repeat_times_3d) # 2. Paddle keyword arguments out2 = paddle.tile(x=x, repeat_times=self.repeat_times_3d) # 3. PyTorch keyword arguments (alias) out3 = paddle.tile(input=x, dims=self.repeat_times_3d) # 4. Mixed arguments out4 = paddle.tile(x, dims=self.repeat_times_3d) # 5. Tensor method - args out5 = x.tile(2, 1, 3) # 6. Tensor method - kwargs (PyTorch alias) out6 = x.tile(dims=self.repeat_times_3d) dims = self.repeat_times_3d # 7. Tensor method - args with variable expansion out7 = x.tile(*dims) # Verify all outputs ref_out = np.tile(self.np_x_3d, self.repeat_times_3d) for out in [out1, out2, out3, out4, out5, out6, out7]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-5) paddle.enable_static() def test_static_HighDimCompatibility(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.shape_3d, dtype=self.dtype_3d ) # 1. Paddle Positional arguments out1 = paddle.tile(x, self.repeat_times_3d) # 2. Paddle keyword arguments out2 = paddle.tile(x=x, repeat_times=self.repeat_times_3d) # 3. PyTorch keyword arguments (alias) out3 = paddle.tile(input=x, dims=self.repeat_times_3d) # 4. Tensor method - args out4 = x.tile(2, 1, 3) # 5. Tensor method - kwargs (PyTorch alias) out5 = x.tile(dims=self.repeat_times_3d) dims = self.repeat_times_3d # 6. Tensor method - args with variable expansion out6 = x.tile(*dims) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x_3d}, fetch_list=[out1, out2, out3, out4, out5, out6], ) # Verify all outputs ref_out = np.tile(self.np_x_3d, self.repeat_times_3d) for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-5) # Test logit compatibility class TestLogitAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.shape = [5, 6] self.dtype = 'float32' self.np_x = np.random.uniform(0.1, 0.9, self.shape).astype(self.dtype) def _ref_logit(self, x, eps=0.0): if eps > 0.0: x = np.clip(x, eps, 1.0 - eps) return np.log(x / (1.0 - x)) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.logit(x) # 2. Paddle keyword arguments out2 = paddle.logit(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.logit(input=x) # 4. Mixed arguments (positional x + keyword eps) out4 = paddle.logit(x, eps=1e-6) # 5. out parameter test out5 = paddle.empty_like(x) paddle.logit(x, out=out5) # 6. out parameter with alias keyword out6 = paddle.empty_like(x) paddle.logit(input=x, out=out6) # 7. Tensor method - args out7 = x.logit() # 8. Tensor method - kwargs out8 = x.logit(eps=1e-6) # 9. paddle.special.logit alias out9 = paddle.special.logit(x) # 10. paddle.special.logit with alias keyword out10 = paddle.special.logit(input=x) # Verify outputs without eps ref_out = self._ref_logit(self.np_x) for out in [out1, out2, out3, out5, out6, out7, out9, out10]: np.testing.assert_allclose( out.numpy(), ref_out, rtol=1e-5, atol=1e-6 ) # Verify outputs with eps ref_out_eps = self._ref_logit(self.np_x, 1e-6) for out in [out4, out8]: np.testing.assert_allclose( out.numpy(), ref_out_eps, rtol=1e-5, atol=1e-6 ) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data(name="x", shape=self.shape, dtype=self.dtype) # 1. Paddle Positional arguments out1 = paddle.logit(x) # 2. Paddle keyword arguments out2 = paddle.logit(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.logit(input=x) # 4. Mixed arguments (positional x + keyword eps) out4 = paddle.logit(x, eps=1e-6) # 5. Tensor method - args out5 = x.logit() exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3, out4, out5], ) # Verify outputs without eps ref_out = self._ref_logit(self.np_x) for out in [fetches[0], fetches[1], fetches[2], fetches[4]]: np.testing.assert_allclose(out, ref_out, rtol=1e-5, atol=1e-6) # Verify output with eps ref_out_eps = self._ref_logit(self.np_x, 1e-6) np.testing.assert_allclose( fetches[3], ref_out_eps, rtol=1e-5, atol=1e-6 ) class TestSpecialErfAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.shape = [3, 4] self.inputs = [ np.random.uniform(-3.0, 3.0, self.shape).astype(dtype) for dtype in ["float32", "float64"] ] def _ref_erf(self, x): return np.array( [math.erf(float(v)) for v in x.flatten()], dtype=x.dtype ).reshape(x.shape) def test_dygraph_Compatibility(self): paddle.disable_static() for np_x in self.inputs: x = paddle.to_tensor(np_x) # 1. Paddle Positional arguments out1 = paddle.special.erf(x) # 2. Paddle keyword arguments out2 = paddle.special.erf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.special.erf(input=x) # 4. out parameter test out4 = paddle.empty_like(x) out5 = paddle.special.erf(x, out=out4) # Verify all outputs expected = self._ref_erf(np_x) for out in [out1, out2, out3, out4, out5]: np.testing.assert_allclose( out.numpy(), expected, rtol=1e-5, atol=1e-6 ) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() for i, np_x in enumerate(self.inputs): main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data( name=f"x_{i}", shape=self.shape, dtype=str(np_x.dtype) ) # 1. Paddle Positional arguments out1 = paddle.special.erf(x) # 2. Paddle keyword arguments out2 = paddle.special.erf(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.special.erf(input=x) exe = paddle.static.Executor() fetches = exe.run( main, feed={f"x_{i}": np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs expected = self._ref_erf(np_x) for out in fetches: np.testing.assert_allclose( out, expected, rtol=1e-5, atol=1e-6 ) class TestSpecialSincAPI(unittest.TestCase): def setUp(self): self.shape = [3, 4] base = np.array( [ [0.0, -3.0, -1.5, -0.25], [0.25, 0.5, 1.0, 1.5], [2.0, 2.5, 3.0, 4.25], ] ) self.inputs = [base.astype(dtype) for dtype in ["float32", "float64"]] def test_dygraph_Compatibility(self): paddle.disable_static() for np_x in self.inputs: x = paddle.to_tensor(np_x) # 1. Paddle Positional arguments out1 = paddle.special.sinc(x) # 2. Paddle keyword arguments out2 = paddle.special.sinc(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.special.sinc(input=x) # 4. out parameter test out4 = paddle.empty_like(x) out5 = paddle.special.sinc(x, out=out4) out6 = paddle.empty_like(x) out7 = paddle.sinc(input=x, out=out6) # Verify all outputs expected = np.sinc(np_x) for out in [out1, out2, out3, out4, out5, out6, out7]: np.testing.assert_allclose( out.numpy(), expected, rtol=1e-5, atol=1e-6 ) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() for i, np_x in enumerate(self.inputs): main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data( name=f"sinc_x_{i}", shape=self.shape, dtype=str(np_x.dtype), ) # 1. Paddle Positional arguments out1 = paddle.special.sinc(x) # 2. Paddle keyword arguments out2 = paddle.special.sinc(x=x) # 3. PyTorch keyword arguments (alias) out3 = paddle.special.sinc(input=x) out4 = paddle.sinc(input=x) exe = paddle.static.Executor() fetches = exe.run( main, feed={f"sinc_x_{i}": np_x}, fetch_list=[out1, out2, out3, out4], ) # Verify all outputs expected = np.sinc(np_x) for out in fetches: np.testing.assert_allclose( out, expected, rtol=1e-5, atol=1e-6 ) # Test conv1d_transpose / conv_transpose1d compatibility @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv1dTransposeAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.dtype = 'float32' self.np_x = np.random.rand(1, 2, 4).astype(self.dtype) self.np_weight = np.random.rand(2, 2, 3).astype(self.dtype) self.np_bias = np.random.rand(2).astype(self.dtype) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) weight = paddle.to_tensor(self.np_weight) bias = paddle.to_tensor(self.np_bias) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv1d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv1d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv1d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose1d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose1d(input=x, weight=weight) # 6. Mixed arguments (positional + keyword) out6 = paddle.nn.functional.conv1d_transpose( x, weight, bias=bias, stride=1, padding=0 ) # 7. Positional arguments with bias out7 = paddle.nn.functional.conv1d_transpose(x, weight, bias) # 8. All positional arguments out8 = paddle.nn.functional.conv1d_transpose( x, weight, bias, 1, 0, 0, 1, 1, None, 'NCL', None ) # 9. All keyword arguments out9 = paddle.nn.functional.conv1d_transpose( x=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCL', name=None, ) # 10. PyTorch alias + all keyword arguments out10 = paddle.nn.functional.conv_transpose1d( input=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCL', name=None, ) # Verify outputs without bias ref = out1.numpy() for out in [out2, out3, out4, out5]: np.testing.assert_allclose(out.numpy(), ref, rtol=1e-5) # Verify outputs with bias ref_bias = out6.numpy() for out in [out7, out8, out9, out10]: np.testing.assert_allclose(out.numpy(), ref_bias, 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=[1, 2, 4], dtype=self.dtype) weight = paddle.static.data( name="weight", shape=[2, 2, 3], dtype=self.dtype ) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv1d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv1d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv1d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose1d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose1d(input=x, weight=weight) # 6. All positional arguments out6 = paddle.nn.functional.conv1d_transpose( x, weight, None, 1, 0, 0, 1, 1, None, 'NCL', None ) # 7. All keyword arguments out7 = paddle.nn.functional.conv1d_transpose( x=x, weight=weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCL', name=None, ) exe = paddle.static.Executor() fetches = exe.run( main, feed={ "x": self.np_x, "weight": self.np_weight, }, fetch_list=[out1, out2, out3, out4, out5, out6, out7], ) # Verify all outputs for i in range(1, len(fetches)): np.testing.assert_allclose(fetches[0], fetches[i], rtol=1e-5) # Test Conv1DTranspose layer compatibility @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv1DTransposeLayerAPI(unittest.TestCase): def test_paddle_style_keyword_only(self): paddle.disable_static() layer = paddle.nn.Conv1DTranspose(2, 2, 3) self.assertIsNotNone(layer.weight) self.assertIsNotNone(layer.bias) def test_bias_false_disables_bias_attr(self): paddle.disable_static() layer = paddle.nn.Conv1DTranspose(2, 2, 3, bias=False) self.assertIsNone(layer.bias) def test_pytorch_style_positional_bias_only(self): paddle.disable_static() layer = paddle.nn.Conv1DTranspose(2, 2, 3, 1, 0, 0, 1, True) self.assertIsNotNone(layer.bias) def test_pytorch_style_full_positional(self): paddle.disable_static() layer = paddle.nn.ConvTranspose1d( 2, 2, 3, 1, 0, 0, 1, False, 1, 'zeros', None, None ) self.assertIsNone(layer.bias) def test_pytorch_style_duplicate_bias_raises(self): paddle.disable_static() with self.assertRaises(TypeError): paddle.nn.Conv1DTranspose(2, 2, 3, 1, 0, 0, 1, True, bias=True) # Test conv2d_transpose / conv_transpose2d compatibility @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv2dTransposeAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.dtype = 'float32' self.np_x = np.random.rand(1, 2, 4, 4).astype(self.dtype) self.np_weight = np.random.rand(2, 2, 3, 3).astype(self.dtype) self.np_bias = np.random.rand(2).astype(self.dtype) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) weight = paddle.to_tensor(self.np_weight) bias = paddle.to_tensor(self.np_bias) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv2d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv2d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv2d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose2d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose2d(input=x, weight=weight) # 6. Mixed arguments (positional + keyword) out6 = paddle.nn.functional.conv2d_transpose( x, weight, bias=bias, stride=1, padding=0 ) # 7. Positional arguments with bias out7 = paddle.nn.functional.conv2d_transpose(x, weight, bias) # 8. All positional arguments out8 = paddle.nn.functional.conv2d_transpose( x, weight, bias, 1, 0, 0, 1, 1, None, 'NCHW', None ) # 9. All keyword arguments out9 = paddle.nn.functional.conv2d_transpose( x=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCHW', name=None, ) # 10. PyTorch alias + all keyword arguments out10 = paddle.nn.functional.conv_transpose2d( input=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCHW', name=None, ) # Verify outputs without bias ref = out1.numpy() for out in [out2, out3, out4, out5]: np.testing.assert_allclose(out.numpy(), ref, rtol=1e-5) # Verify outputs with bias ref_bias = out6.numpy() for out in [out7, out8, out9, out10]: np.testing.assert_allclose(out.numpy(), ref_bias, 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=[1, 2, 4, 4], dtype=self.dtype ) weight = paddle.static.data( name="weight", shape=[2, 2, 3, 3], dtype=self.dtype ) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv2d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv2d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv2d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose2d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose2d(input=x, weight=weight) # 6. All positional arguments out6 = paddle.nn.functional.conv2d_transpose( x, weight, None, 1, 0, 0, 1, 1, None, 'NCHW', None ) # 7. All keyword arguments out7 = paddle.nn.functional.conv2d_transpose( x=x, weight=weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCHW', name=None, ) exe = paddle.static.Executor() fetches = exe.run( main, feed={ "x": self.np_x, "weight": self.np_weight, }, fetch_list=[out1, out2, out3, out4, out5, out6, out7], ) # Verify all outputs for i in range(1, len(fetches)): np.testing.assert_allclose(fetches[0], fetches[i], rtol=1e-5) @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv2DTransposeLayerAPI(unittest.TestCase): def test_paddle_style_keyword_only(self): paddle.disable_static() layer = paddle.nn.Conv2DTranspose(2, 2, 3) self.assertIsNotNone(layer.weight) self.assertIsNotNone(layer.bias) def test_bias_false_disables_bias_attr(self): paddle.disable_static() layer = paddle.nn.Conv2DTranspose(2, 2, 3, bias=False) self.assertIsNone(layer.bias) def test_pytorch_style_positional_bias_only(self): paddle.disable_static() layer = paddle.nn.Conv2DTranspose(2, 2, 3, 1, 0, 0, 1, True) self.assertIsNotNone(layer.bias) def test_pytorch_style_full_positional(self): paddle.disable_static() layer = paddle.nn.ConvTranspose2d( 2, 2, 3, 1, 0, 0, 1, False, 1, 'zeros', None, None ) self.assertIsNone(layer.bias) def test_pytorch_style_duplicate_bias_raises(self): paddle.disable_static() with self.assertRaises(TypeError): paddle.nn.Conv2DTranspose(2, 2, 3, 1, 0, 0, 1, True, bias=True) # Test conv3d_transpose / conv_transpose3d compatibility @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv3dTransposeAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.dtype = 'float32' self.np_x = np.random.rand(1, 2, 4, 4, 4).astype(self.dtype) self.np_weight = np.random.rand(2, 2, 3, 3, 3).astype(self.dtype) self.np_bias = np.random.rand(2).astype(self.dtype) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) weight = paddle.to_tensor(self.np_weight) bias = paddle.to_tensor(self.np_bias) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv3d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv3d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv3d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose3d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose3d(input=x, weight=weight) # 6. Mixed arguments (positional + keyword) out6 = paddle.nn.functional.conv3d_transpose( x, weight, bias=bias, stride=1, padding=0 ) # 7. Positional arguments with bias out7 = paddle.nn.functional.conv3d_transpose(x, weight, bias) # 8. All positional arguments out8 = paddle.nn.functional.conv3d_transpose( x, weight, bias, 1, 0, 0, 1, 1, None, 'NCDHW', None ) # 9. All keyword arguments out9 = paddle.nn.functional.conv3d_transpose( x=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCDHW', name=None, ) # 10. PyTorch alias + all keyword arguments out10 = paddle.nn.functional.conv_transpose3d( input=x, weight=weight, bias=bias, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCDHW', name=None, ) # Verify outputs without bias ref = out1.numpy() for out in [out2, out3, out4, out5]: np.testing.assert_allclose(out.numpy(), ref, rtol=1e-5) # Verify outputs with bias ref_bias = out6.numpy() for out in [out7, out8, out9, out10]: np.testing.assert_allclose(out.numpy(), ref_bias, 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=[1, 2, 4, 4, 4], dtype=self.dtype ) weight = paddle.static.data( name="weight", shape=[2, 2, 3, 3, 3], dtype=self.dtype ) # 1. Paddle Positional arguments out1 = paddle.nn.functional.conv3d_transpose(x, weight) # 2. Paddle keyword arguments out2 = paddle.nn.functional.conv3d_transpose(x=x, weight=weight) # 3. PyTorch keyword arguments (alias: input) out3 = paddle.nn.functional.conv3d_transpose(input=x, weight=weight) # 4. PyTorch function name alias out4 = paddle.nn.functional.conv_transpose3d(x, weight) # 5. PyTorch function name alias + PyTorch keyword out5 = paddle.nn.functional.conv_transpose3d(input=x, weight=weight) # 6. All positional arguments out6 = paddle.nn.functional.conv3d_transpose( x, weight, None, 1, 0, 0, 1, 1, None, 'NCDHW', None ) # 7. All keyword arguments out7 = paddle.nn.functional.conv3d_transpose( x=x, weight=weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1, output_size=None, data_format='NCDHW', name=None, ) exe = paddle.static.Executor() fetches = exe.run( main, feed={ "x": self.np_x, "weight": self.np_weight, }, fetch_list=[out1, out2, out3, out4, out5, out6, out7], ) # Verify all outputs for i in range(1, len(fetches)): np.testing.assert_allclose(fetches[0], fetches[i], rtol=1e-5) # Test Conv3DTranspose layer compatibility @unittest.skipIf( sys.platform == 'win32', "Conv transpose compatibility tests not supported on Windows-Inference", ) class TestConv3DTransposeLayerAPI(unittest.TestCase): def test_paddle_style_keyword_only(self): paddle.disable_static() layer = paddle.nn.Conv3DTranspose(2, 2, 3) self.assertIsNotNone(layer.weight) self.assertIsNotNone(layer.bias) def test_bias_false_disables_bias_attr(self): paddle.disable_static() layer = paddle.nn.Conv3DTranspose(2, 2, 3, bias=False) self.assertIsNone(layer.bias) def test_pytorch_style_positional_bias_only(self): paddle.disable_static() layer = paddle.nn.Conv3DTranspose(2, 2, 3, 1, 0, 0, 1, True) self.assertIsNotNone(layer.bias) def test_pytorch_style_full_positional(self): paddle.disable_static() layer = paddle.nn.ConvTranspose3d( 2, 2, 3, 1, 0, 0, 1, False, 1, 'zeros', None, None ) self.assertIsNone(layer.bias) def test_pytorch_style_duplicate_bias_raises(self): paddle.disable_static() with self.assertRaises(TypeError): paddle.nn.Conv3DTranspose(2, 2, 3, 1, 0, 0, 1, True, bias=True) class TestL1LossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_label = np.random.rand(3, 4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) # 1. Paddle positional arguments out1 = paddle.nn.functional.l1_loss(input, label) # 2. Paddle keyword arguments out2 = paddle.nn.functional.l1_loss(input=input, label=label) # 3. PyTorch keyword arguments (alias) out3 = paddle.nn.functional.l1_loss(input=input, target=label) # 4. Mixed arguments out4 = paddle.nn.functional.l1_loss(input, target=label) ref_out = np.mean(np.abs(self.np_input - self.np_label)) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) # PyTorch deprecated args translate to reduction ref_sum = np.sum(np.abs(self.np_input - self.np_label)) ref_none = np.abs(self.np_input - self.np_label) # 5. size_average=False translates to reduction='sum' out5 = paddle.nn.functional.l1_loss(input, label, size_average=False) np.testing.assert_allclose(out5.numpy(), ref_sum, rtol=1e-6) # 6. reduce=False translates to reduction='none' out6 = paddle.nn.functional.l1_loss(input, label, reduce=False) np.testing.assert_allclose(out6.numpy(), ref_none, rtol=1e-6) # 7. reduce=True + size_average=True translates to reduction='mean' out7 = paddle.nn.functional.l1_loss( input, label, reduce=True, size_average=True ) np.testing.assert_allclose(out7.numpy(), ref_out, rtol=1e-6) # 8. reduce=True + size_average=False translates to reduction='sum' out8 = paddle.nn.functional.l1_loss( input, label, reduce=True, size_average=False ) np.testing.assert_allclose(out8.numpy(), ref_sum, rtol=1e-6) # 9. legacy args combined with target alias out9 = paddle.nn.functional.l1_loss( input=input, target=label, size_average=False ) np.testing.assert_allclose(out9.numpy(), ref_sum, 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): input = paddle.static.data( name="input", shape=[3, 4], dtype='float32' ) label = paddle.static.data( name="label", shape=[3, 4], dtype='float32' ) out1 = paddle.nn.functional.l1_loss(input, label) out2 = paddle.nn.functional.l1_loss(input=input, label=label) out3 = paddle.nn.functional.l1_loss(input=input, target=label) exe = paddle.static.Executor() fetches = exe.run( main, feed={"input": self.np_input, "label": self.np_label}, fetch_list=[out1, out2, out3], ) ref_out = np.mean(np.abs(self.np_input - self.np_label)) for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-6) class TestKLDivAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) # input is log-probability x = np.log(np.random.rand(5, 6).astype("float32") + 1e-3) self.np_input = x self.np_label = np.random.rand(5, 6).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) # 1. Paddle positional arguments out1 = paddle.nn.functional.kl_div(input, label, 'mean') # 2. Paddle keyword arguments out2 = paddle.nn.functional.kl_div(input=input, label=label) # 3. PyTorch keyword arguments (alias) out3 = paddle.nn.functional.kl_div(input=input, target=label) # 4. Mixed arguments out4 = paddle.nn.functional.kl_div(input, target=label) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestSmoothL1LossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_label = np.random.rand(3, 4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) # 1. Paddle positional arguments out1 = paddle.nn.functional.smooth_l1_loss(input, label) # 2. Paddle keyword arguments out2 = paddle.nn.functional.smooth_l1_loss(input=input, label=label) # 3. PyTorch keyword arguments (alias) out3 = paddle.nn.functional.smooth_l1_loss(input=input, target=label) # 4. Mixed arguments out4 = paddle.nn.functional.smooth_l1_loss(input, target=label) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestHingeEmbeddingLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_label = np.random.choice([-1, 1], size=(3, 4)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) out1 = paddle.nn.functional.hinge_embedding_loss(input, label) out2 = paddle.nn.functional.hinge_embedding_loss( input=input, label=label ) out3 = paddle.nn.functional.hinge_embedding_loss( input=input, target=label ) out4 = paddle.nn.functional.hinge_embedding_loss(input, target=label) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestCosineEmbeddingLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input1 = np.random.rand(4, 5).astype("float32") self.np_input2 = np.random.rand(4, 5).astype("float32") self.np_label = np.array([1, -1, 1, -1], dtype="int64") def test_dygraph_Compatibility(self): paddle.disable_static() input1 = paddle.to_tensor(self.np_input1) input2 = paddle.to_tensor(self.np_input2) label = paddle.to_tensor(self.np_label) out1 = paddle.nn.functional.cosine_embedding_loss(input1, input2, label) out2 = paddle.nn.functional.cosine_embedding_loss( input1=input1, input2=input2, label=label ) out3 = paddle.nn.functional.cosine_embedding_loss( input1=input1, input2=input2, target=label ) out4 = paddle.nn.functional.cosine_embedding_loss( input1, input2, target=label ) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestMultiLabelSoftMarginLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_label = np.random.choice([-1, 1], size=(3, 4)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) out1 = paddle.nn.functional.multi_label_soft_margin_loss(input, label) out2 = paddle.nn.functional.multi_label_soft_margin_loss( input=input, label=label ) out3 = paddle.nn.functional.multi_label_soft_margin_loss( input=input, target=label ) out4 = paddle.nn.functional.multi_label_soft_margin_loss( input, target=label ) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestMultiLabelMarginLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(2, 4).astype("float32") self.np_label = np.array( [[3, 0, -1, -1], [0, 2, -1, -1]], dtype="int64" ) def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) out1 = paddle.nn.functional.multi_label_margin_loss(input, label) out2 = paddle.nn.functional.multi_label_margin_loss( input=input, label=label ) out3 = paddle.nn.functional.multi_label_margin_loss( input=input, target=label ) out4 = paddle.nn.functional.multi_label_margin_loss(input, target=label) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestSoftMarginLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_label = np.random.choice([-1, 1], size=(3, 4)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) out1 = paddle.nn.functional.soft_margin_loss(input, label) out2 = paddle.nn.functional.soft_margin_loss(input=input, label=label) out3 = paddle.nn.functional.soft_margin_loss(input=input, target=label) out4 = paddle.nn.functional.soft_margin_loss(input, target=label) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestTripletMarginWithDistanceLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_pos = np.random.rand(3, 4).astype("float32") self.np_neg = np.random.rand(3, 4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) pos = paddle.to_tensor(self.np_pos) neg = paddle.to_tensor(self.np_neg) out1 = paddle.nn.functional.triplet_margin_with_distance_loss( input, pos, neg ) out2 = paddle.nn.functional.triplet_margin_with_distance_loss( input=input, positive=pos, negative=neg ) # PyTorch alias: anchor instead of input out3 = paddle.nn.functional.triplet_margin_with_distance_loss( anchor=input, positive=pos, negative=neg ) for out in [out2, out3]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestTripletMarginLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_pos = np.random.rand(3, 4).astype("float32") self.np_neg = np.random.rand(3, 4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) pos = paddle.to_tensor(self.np_pos) neg = paddle.to_tensor(self.np_neg) out1 = paddle.nn.functional.triplet_margin_loss(input, pos, neg) out2 = paddle.nn.functional.triplet_margin_loss( input=input, positive=pos, negative=neg ) # PyTorch aliases: anchor instead of input, eps instead of epsilon out3 = paddle.nn.functional.triplet_margin_loss( anchor=input, positive=pos, negative=neg, eps=1e-06 ) out4 = paddle.nn.functional.triplet_margin_loss( input, pos, neg, eps=1e-06 ) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestGaussianNLLLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.randn(5, 2).astype("float32") self.np_label = np.random.randn(5, 2).astype("float32") self.np_var = np.ones((5, 2)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) var = paddle.to_tensor(self.np_var) # 1. Paddle positional arguments out1 = paddle.nn.functional.gaussian_nll_loss(input, label, var) # 2. Paddle keyword arguments out2 = paddle.nn.functional.gaussian_nll_loss( input=input, label=label, variance=var ) # 3. PyTorch keyword arguments (aliases) out3 = paddle.nn.functional.gaussian_nll_loss( input=input, target=label, var=var ) # 4. Mixed out4 = paddle.nn.functional.gaussian_nll_loss( input, target=label, var=var, eps=1e-06 ) for out in [out2, out3, out4]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestMarginRankingLossAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(4, 5).astype("float32") self.np_other = np.random.rand(4, 5).astype("float32") self.np_label = np.random.choice([-1, 1], size=(4, 5)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) other = paddle.to_tensor(self.np_other) label = paddle.to_tensor(self.np_label) # 1. Paddle positional arguments out1 = paddle.nn.functional.margin_ranking_loss(input, other, label) # 2. Paddle keyword arguments out2 = paddle.nn.functional.margin_ranking_loss( input=input, other=other, label=label ) # 3. PyTorch keyword arguments (aliases) out3 = paddle.nn.functional.margin_ranking_loss( input1=input, input2=other, target=label ) for out in [out2, out3]: np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-6) paddle.enable_static() class TestGaussianNLLLossLayerAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.randn(5, 2).astype("float32") self.np_label = np.random.randn(5, 2).astype("float32") self.np_var = np.ones((5, 2)).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) var = paddle.to_tensor(self.np_var) # Paddle: epsilon layer1 = paddle.nn.GaussianNLLLoss(epsilon=1e-06) # PyTorch alias: eps layer2 = paddle.nn.GaussianNLLLoss(eps=1e-06) out1 = layer1(input, label, var) out2 = layer2(input, label, var) np.testing.assert_allclose(out1.numpy(), out2.numpy(), rtol=1e-6) paddle.enable_static() class TestPoissonNLLLossLayerAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.randn(5, 2).astype("float32") self.np_label = np.random.randn(5, 2).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) label = paddle.to_tensor(self.np_label) # Paddle: epsilon layer1 = paddle.nn.PoissonNLLLoss(epsilon=1e-08) # PyTorch alias: eps layer2 = paddle.nn.PoissonNLLLoss(eps=1e-08) out1 = layer1(input, label) out2 = layer2(input, label) np.testing.assert_allclose(out1.numpy(), out2.numpy(), rtol=1e-6) paddle.enable_static() class TestTripletMarginLossLayerAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_input = np.random.rand(3, 4).astype("float32") self.np_pos = np.random.rand(3, 4).astype("float32") self.np_neg = np.random.rand(3, 4).astype("float32") def test_dygraph_Compatibility(self): paddle.disable_static() input = paddle.to_tensor(self.np_input) pos = paddle.to_tensor(self.np_pos) neg = paddle.to_tensor(self.np_neg) # Paddle: epsilon layer1 = paddle.nn.TripletMarginLoss(epsilon=1e-06) # PyTorch alias: eps layer2 = paddle.nn.TripletMarginLoss(eps=1e-06) out1 = layer1(input, pos, neg) out2 = layer2(input, pos, neg) np.testing.assert_allclose(out1.numpy(), out2.numpy(), rtol=1e-6) paddle.enable_static() def _assert_unary_inplace_result( testcase, x, out, ref_out, rtol=1e-6, atol=1e-6 ): testcase.assertIs(out, x) np.testing.assert_allclose(out.numpy(), ref_out, rtol=rtol, atol=atol) np.testing.assert_allclose(x.numpy(), ref_out, rtol=rtol, atol=atol) class TestExpInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.exp_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.exp_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.exp_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().exp_() # Verify all outputs ref_out = np.exp(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.exp(self.np_x) out = paddle.exp_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestSqrtInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([0.25, 1.5, 2.25, 4.0], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.sqrt_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.sqrt_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.sqrt_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().sqrt_() # Verify all outputs ref_out = np.sqrt(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.sqrt(self.np_x) out = paddle.sqrt_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestRsqrtInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([0.25, 1.5, 2.25, 4.0], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.rsqrt_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.rsqrt_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.rsqrt_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().rsqrt_() # Verify all outputs ref_out = 1.0 / np.sqrt(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = 1.0 / np.sqrt(self.np_x) out = paddle.rsqrt_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestCeilInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.ceil_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.ceil_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.ceil_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().ceil_() # Verify all outputs ref_out = np.ceil(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.ceil(self.np_x) out = paddle.ceil_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestFloorInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.floor_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.floor_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.floor_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().floor_() # Verify all outputs ref_out = np.floor(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.floor(self.np_x) out = paddle.floor_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestReciprocalInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-2.0, -0.5, 0.25, 4.0], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.reciprocal_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.reciprocal_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.reciprocal_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().reciprocal_() # Verify all outputs ref_out = np.reciprocal(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.reciprocal(self.np_x) out = paddle.reciprocal_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestSigmoidInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.sigmoid_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.sigmoid_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.sigmoid_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().sigmoid_() # Verify all outputs ref_out = 1.0 / (1.0 + np.exp(-self.np_x)) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = 1.0 / (1.0 + np.exp(-self.np_x)) out = paddle.sigmoid_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestSinInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.sin_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.sin_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.sin_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().sin_() # Verify all outputs ref_out = np.sin(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.sin(self.np_x) out = paddle.sin_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestSinhInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.sinh_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.sinh_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.sinh_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().sinh_() # Verify all outputs ref_out = np.sinh(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.sinh(self.np_x) out = paddle.sinh_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAsinInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.9, -0.25, 0.25, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.asin_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.asin_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.asin_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().asin_() # Verify all outputs ref_out = np.arcsin(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arcsin(self.np_x) out = paddle.asin_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAsinhInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.asinh_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.asinh_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.asinh_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().asinh_() # Verify all outputs ref_out = np.arcsinh(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arcsinh(self.np_x) out = paddle.asinh_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestCosInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.cos_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.cos_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.cos_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().cos_() # Verify all outputs ref_out = np.cos(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.cos(self.np_x) out = paddle.cos_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestCoshInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.cosh_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.cosh_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.cosh_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().cosh_() # Verify all outputs ref_out = np.cosh(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.cosh(self.np_x) out = paddle.cosh_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAcosInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.9, -0.25, 0.25, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.acos_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.acos_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.acos_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().acos_() # Verify all outputs ref_out = np.arccos(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arccos(self.np_x) out = paddle.acos_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAcoshInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([1.0, 1.5, 2.0, 3.5], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.acosh_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.acosh_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.acosh_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().acosh_() # Verify all outputs ref_out = np.arccosh(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arccosh(self.np_x) out = paddle.acosh_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestTanInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.tan_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.tan_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.tan_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().tan_() # Verify all outputs ref_out = np.tan(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.tan(self.np_x) out = paddle.tan_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAtanInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.atan_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.atan_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.atan_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().atan_() # Verify all outputs ref_out = np.arctan(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arctan(self.np_x) out = paddle.atan_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestAtanhInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.9, -0.25, 0.25, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.atanh_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.atanh_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.atanh_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().atanh_() # Verify all outputs ref_out = np.arctanh(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.arctanh(self.np_x) out = paddle.atanh_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestExpm1InplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.expm1_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.expm1_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.expm1_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().expm1_() # Verify all outputs ref_out = np.expm1(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.expm1(self.np_x) out = paddle.expm1_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestInvertPermutationAPI(unittest.TestCase): def test_dygraph_Compatibility(self): paddle.disable_static() perm = paddle.to_tensor([2, 0, 1]) # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.invert_permutation(perm) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.invert_permutation(permutation=perm) # 3. None input out3 = paddle.nn.utils.rnn.invert_permutation(None) expected = np.array([1, 2, 0]) np.testing.assert_array_equal(out1.numpy(), expected) np.testing.assert_array_equal(out2.numpy(), expected) self.assertIsNone(out3) paddle.enable_static() class TestPackPaddedSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_seq = np.array( [[4, 5, 6], [1, 2, 0], [3, 0, 0]], dtype=np.float32 ) self.lengths = [3, 2, 1] def test_dygraph_Compatibility(self): paddle.disable_static() seq = paddle.to_tensor(self.np_seq) lengths = paddle.to_tensor(self.lengths) # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.pack_padded_sequence( seq, lengths, batch_first=True ) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.pack_padded_sequence( input=seq, lengths=lengths, batch_first=True ) # 3. Mixed arguments out3 = paddle.nn.utils.rnn.pack_padded_sequence( seq, lengths, batch_first=True ) # 4. enforce_sorted=False out4 = paddle.nn.utils.rnn.pack_padded_sequence( seq, lengths, batch_first=True, enforce_sorted=False ) expected_data = np.array( [4.0, 1.0, 3.0, 5.0, 2.0, 6.0], dtype=np.float32 ) expected_batch_sizes = np.array([3, 2, 1], dtype=np.int64) for out in [out1, out2, out3]: np.testing.assert_allclose(out.data.numpy(), expected_data) np.testing.assert_array_equal( out.batch_sizes.numpy(), expected_batch_sizes ) paddle.enable_static() class TestPadPackedSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_seq = np.array( [[4, 5, 6], [1, 2, 0], [3, 0, 0]], dtype=np.float32 ) self.lengths = [3, 2, 1] def test_dygraph_Compatibility(self): paddle.disable_static() seq = paddle.to_tensor(self.np_seq) lengths = paddle.to_tensor(self.lengths) packed = paddle.nn.utils.rnn.pack_padded_sequence( seq, lengths, batch_first=True ) # 1. Paddle positional arguments out1, lengths1 = paddle.nn.utils.rnn.pad_packed_sequence( packed, batch_first=True ) # 2. Paddle keyword arguments out2, lengths2 = paddle.nn.utils.rnn.pad_packed_sequence( sequence=packed, batch_first=True ) # 3. Mixed arguments out3, lengths3 = paddle.nn.utils.rnn.pad_packed_sequence( packed, batch_first=True, padding_value=0.0 ) for out, lens in [(out1, lengths1), (out2, lengths2), (out3, lengths3)]: np.testing.assert_allclose(out.numpy(), self.np_seq) np.testing.assert_array_equal( lens.numpy(), np.array(self.lengths, dtype=np.int64) ) paddle.enable_static() class TestPadSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.seq1 = np.random.rand(5, 10).astype(np.float32) self.seq2 = np.random.rand(3, 10).astype(np.float32) self.seq3 = np.random.rand(2, 10).astype(np.float32) def test_dygraph_Compatibility(self): paddle.disable_static() seq1 = paddle.to_tensor(self.seq1) seq2 = paddle.to_tensor(self.seq2) seq3 = paddle.to_tensor(self.seq3) sequences = [seq1, seq2, seq3] # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.pad_sequence(sequences) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.pad_sequence(sequences=sequences) # 3. batch_first=True out3 = paddle.nn.utils.rnn.pad_sequence(sequences, batch_first=True) # 4. padding_value out4 = paddle.nn.utils.rnn.pad_sequence(sequences, padding_value=-1.0) # 5. padding_side='left' out5 = paddle.nn.utils.rnn.pad_sequence(sequences, padding_side='left') self.assertEqual(out1.shape, [5, 3, 10]) self.assertEqual(out3.shape, [3, 5, 10]) np.testing.assert_allclose(out1.numpy(), out2.numpy()) paddle.enable_static() class TestUnpadSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.seq1 = np.random.rand(5, 10).astype(np.float32) self.seq2 = np.random.rand(3, 10).astype(np.float32) self.seq3 = np.random.rand(2, 10).astype(np.float32) def test_dygraph_Compatibility(self): paddle.disable_static() seq1 = paddle.to_tensor(self.seq1) seq2 = paddle.to_tensor(self.seq2) seq3 = paddle.to_tensor(self.seq3) sequences = [seq1, seq2, seq3] padded = paddle.nn.utils.rnn.pad_sequence(sequences) lengths = paddle.to_tensor([5, 3, 2]) # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.unpad_sequence(padded, lengths) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.unpad_sequence( padded_sequences=padded, lengths=lengths ) # 3. batch_first=True padded_bf = paddle.nn.utils.rnn.pad_sequence( sequences, batch_first=True ) out3 = paddle.nn.utils.rnn.unpad_sequence( padded_bf, lengths, batch_first=True ) for i, seq in enumerate(sequences): np.testing.assert_allclose(out1[i].numpy(), seq.numpy()) np.testing.assert_allclose(out2[i].numpy(), seq.numpy()) np.testing.assert_allclose(out3[i].numpy(), seq.numpy()) paddle.enable_static() class TestPackSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.seq1 = np.array([1, 2, 3], dtype=np.float32) self.seq2 = np.array([4, 5], dtype=np.float32) self.seq3 = np.array([6], dtype=np.float32) def test_dygraph_Compatibility(self): paddle.disable_static() seq1 = paddle.to_tensor(self.seq1) seq2 = paddle.to_tensor(self.seq2) seq3 = paddle.to_tensor(self.seq3) sequences = [seq1, seq2, seq3] # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.pack_sequence(sequences) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.pack_sequence(sequences=sequences) # 3. enforce_sorted=False out3 = paddle.nn.utils.rnn.pack_sequence( sequences, enforce_sorted=False ) expected_data = np.array( [1.0, 4.0, 6.0, 2.0, 5.0, 3.0], dtype=np.float32 ) expected_batch_sizes = np.array([3, 2, 1], dtype=np.int64) np.testing.assert_allclose(out1.data.numpy(), expected_data) np.testing.assert_array_equal( out1.batch_sizes.numpy(), expected_batch_sizes ) np.testing.assert_allclose(out2.data.numpy(), expected_data) paddle.enable_static() class TestUnpackSequenceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.seq1 = np.array([1, 2, 3], dtype=np.float32) self.seq2 = np.array([4, 5], dtype=np.float32) self.seq3 = np.array([6], dtype=np.float32) def test_dygraph_Compatibility(self): paddle.disable_static() seq1 = paddle.to_tensor(self.seq1) seq2 = paddle.to_tensor(self.seq2) seq3 = paddle.to_tensor(self.seq3) sequences = [seq1, seq2, seq3] packed = paddle.nn.utils.rnn.pack_sequence(sequences) # 1. Paddle positional arguments out1 = paddle.nn.utils.rnn.unpack_sequence(packed) # 2. Paddle keyword arguments out2 = paddle.nn.utils.rnn.unpack_sequence(packed_sequences=packed) for i, seq in enumerate(sequences): np.testing.assert_allclose(out1[i].numpy(), seq) np.testing.assert_allclose(out2[i].numpy(), seq) paddle.enable_static() class TestSquareInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([-0.7, -0.2, 0.3, 0.9], dtype="float32") def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments out1 = paddle.square_(x.clone()) # 2. Paddle keyword arguments out2 = paddle.square_(x=x.clone()) # 3. PyTorch keyword arguments (alias) out3 = paddle.square_(input=x.clone()) # 4. Tensor method - args out4 = x.clone().square_() # Verify all outputs ref_out = np.square(self.np_x) for out in [out1, out2, out3, out4]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) paddle.enable_static() def test_dygraph_InplaceInput(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) ref_out = np.square(self.np_x) out = paddle.square_(x) _assert_unary_inplace_result(self, x, out, ref_out) paddle.enable_static() class TestInferenceModeAPI(unittest.TestCase): def setUp(self): self.np_x = np.array([1.0, 2.0, 3.0], dtype="float32") self.shape = self.np_x.shape self.dtype = str(self.np_x.dtype) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x, stop_gradient=False) # 1. Paddle Positional arguments ctx = paddle.inference_mode() self.assertTrue(paddle.is_grad_enabled()) with ctx: out1 = x * 2 self.assertFalse(paddle.is_grad_enabled()) self.assertTrue(paddle.is_grad_enabled()) # 2. Paddle keyword arguments with paddle.inference_mode(mode=True): out2 = x * 2 self.assertFalse(paddle.is_grad_enabled()) # 3. PyTorch keyword arguments with paddle.no_grad(), paddle.inference_mode(mode=False): out3 = x * 2 self.assertTrue(paddle.is_grad_enabled()) # 4. Decorator without parentheses @paddle.inference_mode def no_grad_decorated(tensor): out = tensor * 2 self.assertFalse(paddle.is_grad_enabled()) return out out4 = no_grad_decorated(x) # 5. Decorator with mode=False @paddle.inference_mode(mode=False) def enable_grad_decorated(tensor): out = tensor * 2 self.assertTrue(paddle.is_grad_enabled()) return out with paddle.no_grad(): out5 = enable_grad_decorated(x) def mode_func(tensor): return tensor * 2 out6 = paddle.inference_mode(mode=mode_func)(x) # Verify all outputs ref_out = self.np_x * 2 for out in [out1, out2, out3, out4, out5, out6]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) for out in [out1, out2, out4, out6]: self.assertTrue(out.stop_gradient) for out in [out3, out5]: self.assertFalse(out.stop_gradient) self.assertTrue(paddle.is_grad_enabled()) 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.shape, dtype=self.dtype) x.stop_gradient = False # 1. Paddle Positional arguments with paddle.inference_mode(): out1 = x * 2 # 2. Paddle keyword arguments with paddle.inference_mode(mode=True): out2 = x * 2 # 3. PyTorch keyword arguments with paddle.no_grad(), paddle.inference_mode(mode=False): out3 = x * 2 exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x}, fetch_list=[out1, out2, out3], ) # Verify all outputs ref_out = self.np_x * 2 for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-6) class TestTensorIndexCopyInplaceAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.zeros((2, 3, 4), dtype="float32") self.np_source_dim1 = ( np.arange(1, 17).reshape(2, 2, 4).astype("float32") ) self.np_source_dim2 = ( np.arange(1, 13).reshape(2, 3, 2).astype("float32") ) def _expected(self, x, dim, index, source): expected = x.copy() for i, idx in enumerate(index): dest_index = [slice(None)] * expected.ndim src_index = [slice(None)] * source.ndim dest_index[dim] = idx src_index[dim] = i expected[tuple(dest_index)] = source[tuple(src_index)] return expected def test_dygraph_Compatibility(self): paddle.disable_static() index = paddle.to_tensor([0, 2], dtype="int64") source_dim1 = paddle.to_tensor(self.np_source_dim1) source_dim2 = paddle.to_tensor(self.np_source_dim2) # 1. Tensor method - positional args x1 = paddle.to_tensor(self.np_x) out1 = x1.index_copy_(1, index, source_dim1) # 2. Tensor method - keyword args x2 = paddle.to_tensor(self.np_x) out2 = x2.index_copy_(dim=1, index=index, source=source_dim1) # 3. Tensor method - mixed args x3 = paddle.to_tensor(self.np_x) out3 = x3.index_copy_(1, index=index, source=source_dim1) # 4. Tensor method - negative dim x4 = paddle.to_tensor(self.np_x) out4 = x4.index_copy_(-1, index, source_dim2) # 5. Tensor method - dim 0 x5 = paddle.zeros([3, 2], dtype="int32") out5 = x5.index_copy_( 0, paddle.to_tensor([0, 2], dtype="int64"), paddle.to_tensor([[3, 4], [5, 6]], dtype="int32"), ) # 6. Tensor method - scalar tensor x6 = paddle.zeros([], dtype="float32") out6 = x6.index_copy_( 0, paddle.to_tensor([0], dtype="int64"), paddle.to_tensor(7.0) ) # 7. Tensor method - scalar source x7 = paddle.zeros([3], dtype="float32") out7 = x7.index_copy_( 0, paddle.to_tensor([1], dtype="int64"), paddle.to_tensor(8.0) ) # 8. Tensor method - empty index x8 = paddle.ones([2, 3], dtype="float32") out8 = x8.index_copy_( 1, paddle.to_tensor([], dtype="int64"), paddle.empty([2, 0], dtype="float32"), ) # 9. Tensor method - scalar index x9 = paddle.zeros([3], dtype="float32") out9 = x9.index_copy_( 0, paddle.to_tensor(1, dtype="int64"), paddle.to_tensor([9.0]) ) # 10. Tensor method - scalar tensor with non-scalar source x10 = paddle.zeros([], dtype="float32") out10 = x10.index_copy_( -1, paddle.to_tensor(0, dtype="int64"), paddle.to_tensor([10.0]) ) # 11. Tensor method - scalar tensor with empty index x11 = paddle.zeros([], dtype="float32") out11 = x11.index_copy_( 0, paddle.to_tensor([], dtype="int64"), paddle.empty([0], dtype="float32"), ) ref_dim1 = self._expected(self.np_x, 1, [0, 2], self.np_source_dim1) ref_dim2 = self._expected(self.np_x, 2, [0, 2], self.np_source_dim2) for out in [out1, out2, out3]: np.testing.assert_allclose(out.numpy(), ref_dim1, rtol=1e-6) np.testing.assert_allclose(out4.numpy(), ref_dim2, rtol=1e-6) np.testing.assert_array_equal( out5.numpy(), np.array([[3, 4], [0, 0], [5, 6]], dtype="int32") ) np.testing.assert_allclose(out6.numpy(), np.array(7.0, dtype="float32")) np.testing.assert_allclose( out7.numpy(), np.array([0.0, 8.0, 0.0], dtype="float32") ) np.testing.assert_allclose( out8.numpy(), np.ones([2, 3], dtype="float32") ) np.testing.assert_allclose( out9.numpy(), np.array([0.0, 9.0, 0.0], dtype="float32") ) np.testing.assert_allclose( out10.numpy(), np.array(10.0, dtype="float32") ) np.testing.assert_allclose( out11.numpy(), np.array(0.0, dtype="float32") ) self.assertIs(out1, x1) self.assertIs(out6, x6) self.assertIs(out10, x10) self.assertIs(out11, x11) with self.assertRaises(IndexError): paddle.zeros([], dtype="float32").index_copy_( 1, paddle.to_tensor([0], dtype="int64"), paddle.to_tensor(7.0) ) with self.assertRaises(RuntimeError): paddle.to_tensor(self.np_x).index_copy_( 1, paddle.to_tensor([0, 2], dtype="int32"), source_dim1, ) with self.assertRaises(RuntimeError): paddle.to_tensor(self.np_x).index_copy_( 1, index, paddle.ones(self.np_source_dim1.shape, dtype="float64"), ) with self.assertRaises(IndexError): paddle.to_tensor(self.np_x).index_copy_( 1, paddle.to_tensor([[0, 2]], dtype="int64"), source_dim1, ) with self.assertRaises(IndexError): paddle.to_tensor(self.np_x).index_copy_( 1, index, paddle.ones([2, 2], dtype="float32"), ) with self.assertRaises(IndexError): paddle.to_tensor(self.np_x).index_copy_( 1, paddle.to_tensor([0], dtype="int64"), source_dim1, ) with self.assertRaises(IndexError): paddle.zeros([3], dtype="float32").index_copy_( 0, paddle.to_tensor([0, 1], dtype="int64"), paddle.to_tensor(7.0), ) with self.assertRaises(RuntimeError): paddle.to_tensor(self.np_x).index_copy_( 1, index, paddle.ones([2, 2, 3], dtype="float32"), ) with self.assertRaises(IndexError): paddle.zeros([3], dtype="float32").index_copy_( 0, paddle.to_tensor([-1], dtype="int64"), paddle.to_tensor([7.0]), ) with self.assertRaises(IndexError): paddle.zeros([3], dtype="float32").index_copy_( 0, paddle.to_tensor([3], dtype="int64"), paddle.to_tensor([7.0]), ) paddle.enable_static() def test_dygraph_functionality(self): paddle.disable_static() x = paddle.arange(60, dtype="float64").reshape([3, 4, 5]) source = paddle.arange(100, 140, dtype="float64").reshape([2, 4, 5]) out = x.index_copy_(0, paddle.to_tensor([2, 0], dtype="int64"), source) expected = self._expected( np.arange(60).reshape([3, 4, 5]).astype("float64"), 0, [2, 0], np.arange(100, 140).reshape([2, 4, 5]).astype("float64"), ) np.testing.assert_allclose(out.numpy(), expected, rtol=1e-6) self.assertIs(out, x) x = paddle.zeros([2, 0, 3], dtype="float32") source = paddle.empty([2, 0, 0], dtype="float32") out = x.index_copy_(2, paddle.to_tensor([], dtype="int64"), source) np.testing.assert_allclose(out.numpy(), np.zeros([2, 0, 3], "float32")) x = paddle.ones([3, 2], dtype="float32") source = paddle.to_tensor([[2.0, 3.0], [4.0, 5.0]]) out = x.index_copy_(0, paddle.to_tensor([2, 0], dtype="int64"), source) np.testing.assert_allclose( out.numpy(), np.array([[4.0, 5.0], [1.0, 1.0], [2.0, 3.0]], dtype="float32"), ) paddle.enable_static() def test_dygraph_backward(self): paddle.disable_static() x = paddle.arange(6, dtype="float32").reshape([3, 2]) x.stop_gradient = False source = paddle.to_tensor( [[7.0, 8.0], [9.0, 10.0]], stop_gradient=False ) out = x.clone().index_copy_( 0, paddle.to_tensor([0, 2], dtype="int64"), source ) out.sum().backward() np.testing.assert_allclose( out.numpy(), np.array([[7.0, 8.0], [2.0, 3.0], [9.0, 10.0]], dtype="float32"), rtol=1e-6, ) np.testing.assert_allclose( x.grad.numpy(), np.array([[0.0, 0.0], [1.0, 1.0], [0.0, 0.0]], dtype="float32"), rtol=1e-6, ) np.testing.assert_allclose( source.grad.numpy(), np.ones([2, 2], dtype="float32"), rtol=1e-6 ) paddle.enable_static() class TestKaiserWindowAPI(unittest.TestCase): def setUp(self): self.window_length = 7 self.beta = 6.0 def _expected( self, window_length, periodic=True, beta=12.0, dtype="float32" ): if window_length <= 1: return np.ones((window_length,), dtype=dtype) length = window_length + 1 if periodic else window_length n = np.arange(length, dtype=dtype) alpha = (length - 1) / 2.0 out = np.i0(beta * np.sqrt(1 - ((n - alpha) / alpha) ** 2.0)) / np.i0( beta ) if periodic: out = out[:-1] return out.astype(dtype) def test_dygraph_Compatibility(self): paddle.disable_static() # 1. Paddle Positional arguments out1 = paddle.kaiser_window( self.window_length, False, self.beta, dtype='float64' ) # 2. Paddle keyword arguments out2 = paddle.kaiser_window( window_length=self.window_length, periodic=False, beta=self.beta, dtype='float64', ) # 3. Mixed arguments out3 = paddle.kaiser_window( self.window_length, periodic=False, beta=self.beta, dtype='float64' ) # 4-5. out parameter test out4 = paddle.empty([self.window_length], dtype='float64') out5 = paddle.kaiser_window( self.window_length, False, self.beta, dtype='float64', out=out4, ) self.assertIs(out4, out5) # 6. Explicit dtype=None compatibility out6 = paddle.kaiser_window(3, dtype=None) # 7. strided layout compatibility out7 = paddle.kaiser_window( self.window_length, False, self.beta, dtype='float64', layout='strided', ) # 8. window_length=0 edge case out8 = paddle.kaiser_window(0) # 9. window_length=1 edge case out9 = paddle.kaiser_window(1, dtype='float64') expected = self._expected( self.window_length, periodic=False, beta=self.beta, dtype='float64' ) for out in [out1, out2, out3, out4, out5, out7]: np.testing.assert_allclose(out.numpy(), expected, rtol=1e-12) np.testing.assert_allclose(out6.numpy(), self._expected(3), rtol=1e-5) self.assertEqual(out6.dtype, paddle.float32) np.testing.assert_allclose(out8.numpy(), np.ones((0,), dtype='float32')) np.testing.assert_allclose(out9.numpy(), np.ones((1,), dtype='float64')) self.assertEqual(out9.dtype, paddle.float64) with self.assertRaises(RuntimeError): paddle.kaiser_window(3, layout='sparse') 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): # 1. Paddle Positional arguments out1 = paddle.kaiser_window( self.window_length, False, self.beta, dtype='float64' ) # 2. Paddle keyword arguments out2 = paddle.kaiser_window( window_length=self.window_length, periodic=False, beta=self.beta, dtype='float64', ) # 3. Mixed arguments out3 = paddle.kaiser_window( self.window_length, periodic=False, beta=self.beta, dtype='float64', ) # 4. Explicit dtype=None compatibility out4 = paddle.kaiser_window(3, dtype=None) # 5. strided layout compatibility out5 = paddle.kaiser_window( self.window_length, False, self.beta, dtype='float64', layout='strided', ) exe = paddle.static.Executor() fetches = exe.run( main, fetch_list=[out1, out2, out3, out4, out5], ) expected = self._expected( self.window_length, periodic=False, beta=self.beta, dtype='float64' ) for out in fetches[:3] + fetches[4:]: np.testing.assert_allclose(out, expected, rtol=1e-12) np.testing.assert_allclose(fetches[3], self._expected(3), rtol=1e-5) class TestLayerNormAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.normalized_shape = [2, 3] self.x_shape = [2, 2, 3] self.eps = 1e-5 self.np_x = np.random.rand(*self.x_shape).astype("float32") def _expected(self): axes = tuple( range( len(self.x_shape) - len(self.normalized_shape), len(self.x_shape), ) ) mean = np.mean(self.np_x, axis=axes, keepdims=True) var = np.var(self.np_x, axis=axes, keepdims=True) return (self.np_x - mean) / np.sqrt(var + self.eps) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) # 1. Paddle Positional arguments layer1 = paddle.nn.LayerNorm(self.normalized_shape, self.eps) out1 = layer1(x) # 2. Paddle keyword arguments layer2 = paddle.nn.LayerNorm( normalized_shape=self.normalized_shape, epsilon=self.eps ) out2 = layer2(x) # 3. PyTorch Positional arguments layer3 = paddle.nn.LayerNorm(self.normalized_shape, self.eps, False) out3 = layer3(x) # 4. PyTorch keyword arguments (alias) layer4 = paddle.nn.LayerNorm( normalized_shape=self.normalized_shape, eps=self.eps, elementwise_affine=False, ) out4 = layer4(x) # 5. Mixed arguments layer5 = paddle.nn.LayerNorm( self.normalized_shape, eps=self.eps, bias=False ) out5 = layer5(x) # 6. PyTorch positional bias/device/dtype arguments layer6 = paddle.nn.LayerNorm( self.normalized_shape, self.eps, True, True, None, "float64" ) expected = self._expected() for out in [out1, out2, out3, out4, out5]: np.testing.assert_allclose(out.numpy(), expected, rtol=1e-5) self.assertIsNone(layer3.weight) self.assertIsNone(layer3.bias) self.assertIsNotNone(layer5.weight) self.assertIsNone(layer5.bias) self.assertEqual(layer6.weight.dtype, paddle.float64) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): x = paddle.static.data( name="x", shape=self.x_shape, dtype=str(self.np_x.dtype) ) # 1. Paddle Positional arguments layer1 = paddle.nn.LayerNorm(self.normalized_shape, self.eps) out1 = layer1(x) # 2. Paddle keyword arguments layer2 = paddle.nn.LayerNorm( normalized_shape=self.normalized_shape, epsilon=self.eps ) out2 = layer2(x) # 3. PyTorch Positional arguments layer3 = paddle.nn.LayerNorm(self.normalized_shape, self.eps, False) out3 = layer3(x) # 4. PyTorch keyword arguments (alias) layer4 = paddle.nn.LayerNorm( normalized_shape=self.normalized_shape, eps=self.eps, elementwise_affine=False, ) out4 = layer4(x) self.assertIsNone(layer3.weight) self.assertIsNone(layer3.bias) 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() for out in fetches: np.testing.assert_allclose(out, expected, rtol=1e-5) class TestMultivariateNormalAPI(unittest.TestCase): def setUp(self): self.place = paddle.CPUPlace() self.np_loc = np.array([2.0, -1.0], dtype="float32") self.np_cov = np.array([[2.0, 0.5], [0.5, 1.5]], dtype="float32") self.np_value = np.array([0.2, -0.8], dtype="float32") self.np_scale_tril = np.linalg.cholesky(self.np_cov) self.expected_mean = self.np_loc self.expected_variance = np.diag(self.np_cov) self.expected_entropy = ( 0.5 * self.np_loc.shape[0] * (1.0 + np.log(2 * np.pi)) + np.log(np.diag(self.np_scale_tril)).sum() ) diff = self.np_value - self.np_loc mahalanobis = diff @ np.linalg.solve(self.np_cov, diff) self.expected_log_prob = ( -0.5 * (self.np_loc.shape[0] * np.log(2 * np.pi) + mahalanobis) - np.log(np.diag(self.np_scale_tril)).sum() ) def tearDown(self): paddle.enable_static() def test_dygraph_Compatibility(self): paddle.disable_static() loc = paddle.to_tensor(self.np_loc, place=self.place) cov = paddle.to_tensor(self.np_cov, place=self.place) value = paddle.to_tensor(self.np_value, place=self.place) # 1. Paddle Positional arguments out1 = paddle.distribution.MultivariateNormal(loc, cov) # 2. Paddle keyword arguments out2 = paddle.distribution.MultivariateNormal( loc=loc, covariance_matrix=cov ) # 3. PyTorch Positional arguments out3 = paddle.distribution.MultivariateNormal( loc, cov, None, None, False ) # 4. PyTorch keyword arguments out4 = paddle.distribution.MultivariateNormal( loc=loc, covariance_matrix=cov, validate_args=True ) # 5. Mixed arguments out5 = paddle.distribution.MultivariateNormal( loc, covariance_matrix=cov, validate_args=None ) for out in [out1, out2, out3, out4, out5]: np.testing.assert_allclose(out.mean.numpy(), self.expected_mean) np.testing.assert_allclose( out.variance.numpy(), self.expected_variance ) np.testing.assert_allclose( out.entropy().numpy(), self.expected_entropy, rtol=1e-5 ) np.testing.assert_allclose( out.log_prob(value).numpy(), self.expected_log_prob, 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): loc = paddle.static.data( name="loc", shape=self.np_loc.shape, dtype=str(self.np_loc.dtype), ) cov = paddle.static.data( name="cov", shape=self.np_cov.shape, dtype=str(self.np_cov.dtype), ) value = paddle.static.data( name="value", shape=self.np_value.shape, dtype=str(self.np_value.dtype), ) # 1. Paddle Positional arguments out1 = paddle.distribution.MultivariateNormal(loc, cov) # 2. Paddle keyword arguments out2 = paddle.distribution.MultivariateNormal( loc=loc, covariance_matrix=cov ) # 3. PyTorch Positional arguments out3 = paddle.distribution.MultivariateNormal( loc, cov, None, None, False ) # 4. PyTorch keyword arguments out4 = paddle.distribution.MultivariateNormal( loc=loc, covariance_matrix=cov, validate_args=True ) # 5. Mixed arguments out5 = paddle.distribution.MultivariateNormal( loc, covariance_matrix=cov, validate_args=None ) fetches = [] for out in [out1, out2, out3, out4, out5]: fetches.extend( [out.mean, out.variance, out.entropy(), out.log_prob(value)] ) exe = paddle.static.Executor(self.place) outputs = exe.run( main, feed={ "loc": self.np_loc, "cov": self.np_cov, "value": self.np_value, }, fetch_list=fetches, ) for i in range(0, len(outputs), 4): np.testing.assert_allclose(outputs[i], self.expected_mean) np.testing.assert_allclose(outputs[i + 1], self.expected_variance) np.testing.assert_allclose( outputs[i + 2], self.expected_entropy, rtol=1e-5 ) np.testing.assert_allclose( outputs[i + 3], self.expected_log_prob, rtol=1e-5 ) class TestDistributionAPI(unittest.TestCase): def tearDown(self): paddle.distribution.Distribution.set_default_validate_args(__debug__) paddle.enable_static() def test_dygraph_Compatibility(self): paddle.disable_static() distribution_cls = paddle.distribution.Distribution # 1. Paddle Positional arguments distribution_cls.set_default_validate_args(False) out1 = distribution_cls((2,), (3,)) # 2. Paddle keyword arguments out2 = distribution_cls( batch_shape=[2], event_shape=[3], validate_args=True ) # 3. Mixed arguments out3 = distribution_cls((2,), event_shape=[3], validate_args=False) # Verify constructor compatibility self.assertEqual(out1.batch_shape, (2,)) self.assertEqual(out1.event_shape, (3,)) self.assertFalse(out1._validate_args_enabled) self.assertTrue(out2._validate_args_enabled) self.assertFalse(out3._validate_args_enabled) self.assertTrue(callable(out2._validate_args)) with self.assertRaises(ValueError): distribution_cls.set_default_validate_args(None) value = paddle.to_tensor([0.5], dtype="float32") for attr in ["arg_constraints", "support"]: with self.assertRaises(NotImplementedError): getattr(out1, attr) for api in [out1.cdf, out1.icdf]: with self.assertRaises(NotImplementedError): api(value) with self.assertRaises(NotImplementedError): out1.enumerate_support() with self.assertRaises(NotImplementedError): out1.sample_n(3) with self.assertRaises(NotImplementedError): out1.perplexity() paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() paddle.distribution.Distribution.set_default_validate_args(True) main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): distribution_cls = paddle.distribution.Distribution # 1. Paddle Positional arguments out1 = distribution_cls((2,), (3,), validate_args=False) # 2. Paddle keyword arguments out2 = distribution_cls( batch_shape=[2], event_shape=[3], validate_args=True ) # 3. Mixed arguments out3 = distribution_cls((2,), event_shape=[3]) self.assertEqual(out1.batch_shape, (2,)) self.assertEqual(out1.event_shape, (3,)) self.assertFalse(out1._validate_args_enabled) self.assertTrue(out2._validate_args_enabled) self.assertTrue(out3._validate_args_enabled) self.assertTrue(callable(out1._validate_args)) with self.assertRaises(NotImplementedError): out1.sample_n(3) with self.assertRaises(NotImplementedError): out1.perplexity() class TestNormalValidateArgsAPI(unittest.TestCase): def setUp(self): self.place = paddle.CPUPlace() self.np_loc = np.array([0.0, 1.0, -1.0], dtype="float32") self.np_scale = np.array([1.0, 2.0, 0.5], dtype="float32") self.np_value = np.array([0.2, 0.8, -0.3], dtype="float32") def tearDown(self): paddle.distribution.Distribution.set_default_validate_args(__debug__) paddle.enable_static() def _expected_log_prob(self): var = self.np_scale * self.np_scale return ( -((self.np_value - self.np_loc) * (self.np_value - self.np_loc)) / (2.0 * var) - np.log(self.np_scale) - np.log(np.sqrt(2.0 * np.pi)) ) def test_dygraph_Compatibility(self): paddle.disable_static() paddle.distribution.Distribution.set_default_validate_args(False) loc = paddle.to_tensor(self.np_loc, place=self.place) scale = paddle.to_tensor(self.np_scale, place=self.place) value = paddle.to_tensor(self.np_value, place=self.place) # 1. Paddle Positional arguments dist1 = paddle.distributions.normal.Normal(loc, scale) out1 = dist1.log_prob(value) # 2. Paddle keyword arguments dist2 = paddle.distributions.normal.Normal(loc=loc, scale=scale) out2 = dist2.log_prob(value) # 3. PyTorch Positional arguments dist3 = paddle.distributions.normal.Normal(loc, scale, False) out3 = dist3.log_prob(value) # 4. PyTorch keyword arguments dist4 = paddle.distributions.normal.Normal( loc=loc, scale=scale, validate_args=False ) out4 = dist4.log_prob(value) # 5. Mixed arguments dist5 = paddle.distributions.normal.Normal(loc, scale=scale) out5 = dist5.log_prob(value) ref_out = self._expected_log_prob() for out in [out1, out2, out3, out4, out5]: np.testing.assert_allclose(out.numpy(), ref_out, rtol=1e-6) self.assertFalse(dist3._validate_args_enabled) self.assertFalse(dist4._validate_args_enabled) paddle.enable_static() def test_static_Compatibility(self): paddle.enable_static() paddle.distribution.Distribution.set_default_validate_args(False) main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): loc = paddle.static.data( name="loc", shape=self.np_loc.shape, dtype="float32" ) scale = paddle.static.data( name="scale", shape=self.np_scale.shape, dtype="float32" ) value = paddle.static.data( name="value", shape=self.np_value.shape, dtype="float32" ) # 1. Paddle Positional arguments out1 = paddle.distributions.normal.Normal(loc, scale).log_prob( value ) # 2. Paddle keyword arguments out2 = paddle.distributions.normal.Normal( loc=loc, scale=scale ).log_prob(value) # 3. PyTorch Positional arguments out3 = paddle.distributions.normal.Normal( loc, scale, False ).log_prob(value) # 4. PyTorch keyword arguments out4 = paddle.distributions.normal.Normal( loc=loc, scale=scale, validate_args=False ).log_prob(value) # 5. Mixed arguments out5 = paddle.distributions.normal.Normal( loc, scale=scale ).log_prob(value) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "loc": self.np_loc, "scale": self.np_scale, "value": self.np_value, }, fetch_list=[out1, out2, out3, out4, out5], ) ref_out = self._expected_log_prob() for out in fetches: np.testing.assert_allclose(out, ref_out, rtol=1e-6) class TestDistributionSampleShapeAliasAPI(unittest.TestCase): def setUp(self): self.place = paddle.CPUPlace() self.np_loc = np.array([0.0, 1.0], dtype="float32") self.np_scale = np.array([1.0, 2.0], dtype="float32") def tearDown(self): paddle.enable_static() def _check_shape(self, tensor, expected): self.assertEqual(list(tensor.shape), expected) def test_normal_sample_shape_alias(self): paddle.disable_static() loc = paddle.to_tensor(self.np_loc, place=self.place) scale = paddle.to_tensor(self.np_scale, place=self.place) dist = paddle.distributions.Normal(loc, scale) self._check_shape(dist.sample(shape=[2, 3]), [2, 3, 2]) self._check_shape(dist.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(dist.rsample(shape=[2, 3]), [2, 3, 2]) self._check_shape(dist.rsample(sample_shape=[2, 3]), [2, 3, 2]) paddle.enable_static() def test_normal_sample_shape_alias_static(self): paddle.enable_static() main = paddle.static.Program() startup = paddle.static.Program() with paddle.static.program_guard(main, startup): loc = paddle.static.data( name="loc", shape=self.np_loc.shape, dtype="float32" ) scale = paddle.static.data( name="scale", shape=self.np_scale.shape, dtype="float32" ) dist = paddle.distributions.Normal(loc, scale) out1 = dist.sample(shape=[2, 3]) out2 = dist.sample(sample_shape=[2, 3]) out3 = dist.rsample(shape=[2, 3]) out4 = dist.rsample(sample_shape=[2, 3]) exe = paddle.static.Executor(self.place) fetches = exe.run( main, feed={ "loc": self.np_loc, "scale": self.np_scale, }, fetch_list=[out1, out2, out3, out4], ) for out in fetches: self._check_shape(out, [2, 3, 2]) def test_dygraph_Compatibility(self): paddle.disable_static() normal = paddle.distributions.Normal( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]), ) self._check_shape(normal.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(normal.rsample(sample_shape=[2, 3]), [2, 3, 2]) cauchy = paddle.distributions.Cauchy( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]) ) self._check_shape(cauchy.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(cauchy.rsample(sample_shape=[2, 3]), [2, 3, 2]) laplace = paddle.distributions.Laplace( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]) ) self._check_shape(laplace.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(laplace.rsample(sample_shape=[2, 3]), [2, 3, 2]) exponential = paddle.distributions.Exponential( paddle.to_tensor([1.0, 2.0]) ) self._check_shape(exponential.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(exponential.rsample(sample_shape=[2, 3]), [2, 3, 2]) gamma = paddle.distributions.Gamma( paddle.to_tensor([1.0, 2.0]), paddle.to_tensor([2.0, 3.0]) ) self._check_shape(gamma.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(gamma.rsample(sample_shape=[2, 3]), [2, 3, 2]) geometric = paddle.distributions.Geometric(paddle.to_tensor([0.2, 0.7])) self._check_shape(geometric.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(geometric.rsample(sample_shape=[2, 3]), [2, 3, 2]) gumbel = paddle.distributions.Gumbel( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]) ) self._check_shape(gumbel.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(gumbel.rsample(sample_shape=[2, 3]), [2, 3, 2]) continuous_bernoulli = paddle.distributions.ContinuousBernoulli( paddle.to_tensor([0.3, 0.7]) ) self._check_shape( continuous_bernoulli.sample(sample_shape=[2, 3]), [2, 3, 2] ) self._check_shape( continuous_bernoulli.rsample(sample_shape=[2, 3]), [2, 3, 2] ) bernoulli = paddle.distributions.Bernoulli(paddle.to_tensor([0.3, 0.7])) self._check_shape(bernoulli.sample(sample_shape=[2, 3]), [2, 3, 2]) binomial = paddle.distributions.Binomial( 10, paddle.to_tensor([0.3, 0.7]) ) self._check_shape(binomial.sample(sample_shape=[2, 3]), [2, 3, 2]) categorical = paddle.distributions.Categorical( paddle.to_tensor([0.2, 0.3, 0.5]) ) self._check_shape(categorical.sample(sample_shape=[2, 3]), [2, 3]) dirichlet = paddle.distributions.Dirichlet( paddle.to_tensor([1.0, 2.0, 3.0]) ) self._check_shape(dirichlet.sample(sample_shape=[2, 3]), [2, 3, 3]) independent = paddle.distributions.Independent( paddle.distributions.Normal( paddle.to_tensor([[0.0, 1.0], [2.0, 3.0]]), paddle.to_tensor([[1.0, 1.0], [1.0, 1.0]]), ), 1, ) self._check_shape(independent.sample(sample_shape=[2, 3]), [2, 3, 2, 2]) multivariate_normal = paddle.distributions.MultivariateNormal( paddle.to_tensor([0.0, 1.0]), covariance_matrix=paddle.eye(2, dtype="float32"), ) self._check_shape( multivariate_normal.sample(sample_shape=[2, 3]), [2, 3, 2] ) self._check_shape( multivariate_normal.rsample(sample_shape=[2, 3]), [2, 3, 2] ) poisson = paddle.distributions.Poisson(paddle.to_tensor([1.0, 2.0])) self._check_shape(poisson.sample(sample_shape=[2, 3]), [2, 3, 2]) student_t = paddle.distributions.StudentT( paddle.to_tensor([2.5, 3.5]), paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 1.5]), ) self._check_shape(student_t.sample(sample_shape=[2, 3]), [2, 3, 2]) transformed = paddle.distributions.TransformedDistribution( paddle.distributions.Normal( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]), ), [ paddle.distributions.AffineTransform( loc=paddle.to_tensor(1.0), scale=paddle.to_tensor(2.0) ) ], ) self._check_shape(transformed.sample(sample_shape=[2, 3]), [2, 3, 2]) self._check_shape(transformed.rsample(sample_shape=[2, 3]), [2, 3, 2]) uniform = paddle.distributions.Uniform( paddle.to_tensor([0.0, 1.0]), paddle.to_tensor([1.0, 2.0]) ) self._check_shape(uniform.sample(sample_shape=[2, 3]), [2, 3, 2]) paddle.enable_static() class TestTensorTransposeInplaceAPI(unittest.TestCase): def setUp(self): self.np_x = np.arange(24).reshape(2, 3, 4).astype("float32") def _check_output(self, out, expected): np.testing.assert_allclose(out.numpy(), expected) self.assertEqual(tuple(out.shape), expected.shape) def test_dygraph_Compatibility(self): if paddle.is_compiled_with_xpu(): self.skipTest("transpose_ is not supported on XPU") paddle.disable_static() expected_swap_01 = np.transpose(self.np_x, (1, 0, 2)) expected_swap_n10 = np.transpose(self.np_x, (2, 1, 0)) # 1. Paddle Positional arguments x1 = paddle.to_tensor(self.np_x) out1 = x1.transpose_([1, 0, 2]) # 2. Paddle keyword arguments x2 = paddle.to_tensor(self.np_x) out2 = x2.transpose_(perm=[1, 0, 2]) # 3. PyTorch Positional arguments x3 = paddle.to_tensor(self.np_x) out3 = x3.transpose_(0, 1) # 4. PyTorch keyword arguments x4 = paddle.to_tensor(self.np_x) out4 = x4.transpose_(dim0=0, dim1=1) # 5. Mixed arguments x5 = paddle.to_tensor(self.np_x) out5 = x5.transpose_(0, dim1=1) # 6. PyTorch keyword arguments out of order x6 = paddle.to_tensor(self.np_x) out6 = x6.transpose_(dim1=1, dim0=0) # 7. PyTorch negative dim arguments x7 = paddle.to_tensor(self.np_x) out7 = x7.transpose_(-1, 0) # 8. PyTorch same dim arguments x8 = paddle.to_tensor(self.np_x) out8 = x8.transpose_(1, 1) for out in [out1, out2, out3, out4, out5, out6]: self._check_output(out, expected_swap_01) self._check_output(out7, expected_swap_n10) self._check_output(out8, self.np_x) paddle.enable_static() class TestTensorReshapeAsAPI(unittest.TestCase): def setUp(self): np.random.seed(2025) self.np_x = np.arange(24).astype("float32") self.np_other = np.random.rand(2, 3, 4).astype("float64") self.expected = self.np_x.reshape(self.np_other.shape) def test_dygraph_Compatibility(self): paddle.disable_static() x = paddle.to_tensor(self.np_x) other = paddle.to_tensor(self.np_other) # 1. Tensor method - args out1 = x.reshape_as(other) # 2. Tensor method - kwargs out2 = x.reshape_as(other=other) for out in [out1, out2]: np.testing.assert_allclose(out.numpy(), self.expected) 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) ) other = paddle.static.data( name="other", shape=self.np_other.shape, dtype=str(self.np_other.dtype), ) # 1. Tensor method - args out1 = x.reshape_as(other) # 2. Tensor method - kwargs out2 = x.reshape_as(other=other) exe = paddle.static.Executor() fetches = exe.run( main, feed={"x": self.np_x, "other": self.np_other}, fetch_list=[out1, out2], ) for out in fetches: np.testing.assert_allclose(out, self.expected) if __name__ == "__main__": unittest.main()