wehub-resource-sync
1358 lines
46 KiB
Python
1358 lines
46 KiB
Python
# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import unittest
|
|
|
|
import numpy as np
|
|
|
|
import paddle
|
|
|
|
|
|
# Test select_scatter compatibility
|
|
class TestSelectScatterAPI(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")
|
|
|
|
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, 1, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.select_scatter(x=x, values=values, axis=1, index=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.select_scatter(input=x, src=values, dim=1, index=1)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.select_scatter(x, values, axis=1, index=1)
|
|
# 5. Tensor method - args
|
|
out5 = x.select_scatter(values, 1, 1)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
self.assertEqual(out.shape, (2, 3, 4))
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=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, 1, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.select_scatter(x=x, values=values, axis=1, index=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.select_scatter(input=x, src=values, dim=1, index=1)
|
|
# 4. Tensor method - args
|
|
out4 = x.select_scatter(values, 1, 1)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "values": self.np_values},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test sgn compatibility
|
|
class TestSgnAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([3.0, -2.0, 0.0, -5.0]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.sgn(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.sgn(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.sgn(input=x)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.sgn(x, name=None)
|
|
# 5. Tensor method - args
|
|
out5 = x.sgn()
|
|
# 6. out parameter test
|
|
out6 = paddle.empty_like(out1)
|
|
paddle.sgn(x, out=out6)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=self.np_x.shape, dtype=str(self.np_x.dtype)
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.sgn(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.sgn(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.sgn(input=x)
|
|
# 4. Tensor method - args
|
|
out4 = x.sgn()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test signbit compatibility
|
|
class TestSignbitAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([-0.0, 1.1, -2.1, 0.0, 2.5]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.signbit(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.signbit(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.signbit(input=x)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.signbit(x, name=None)
|
|
# 5. Tensor method - args
|
|
out5 = x.signbit()
|
|
# 6. out parameter test
|
|
out6 = paddle.empty_like(out1)
|
|
paddle.signbit(x, out=out6)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5, out6]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=self.np_x.shape, dtype=str(self.np_x.dtype)
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.signbit(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.signbit(x=x)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.signbit(input=x)
|
|
# 4. Tensor method - args
|
|
out4 = x.signbit()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test slice_scatter compatibility
|
|
class TestSliceScatterAPI(unittest.TestCase):
|
|
"""Test slice_scatter decorator compatibility.
|
|
|
|
PyTorch: torch.slice_scatter(input, src, dim=0, start=None, end=None, step=1)
|
|
Paddle: paddle.slice_scatter(x, value, axes, starts, ends, strides)
|
|
|
|
The decorator handles:
|
|
1. PyTorch style positional args (dim/start/end/step are int, triggers is_paddle_style=False)
|
|
2. PyTorch keyword aliases (input/src/dim/start/end/step)
|
|
3. end=None handling
|
|
4. Auto-calc ends when not provided
|
|
"""
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
# 1. PyTorch style positional args (is_paddle_style=False branch)
|
|
# Full positional args: dim=1, start=2, end=6, step=2
|
|
x = paddle.zeros((3, 8))
|
|
value = paddle.ones((3, 2))
|
|
out = paddle.slice_scatter(x, value, 1, 2, 6, 2)
|
|
expected = np.zeros((3, 8))
|
|
expected[:, 2] = 1.0
|
|
expected[:, 4] = 1.0
|
|
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-5)
|
|
|
|
# Only dim, start (step defaults to 1)
|
|
x2 = paddle.zeros((3, 8))
|
|
value2 = paddle.ones((3, 4))
|
|
out2 = paddle.slice_scatter(x2, value2, 1, 2)
|
|
expected2 = np.zeros((3, 8))
|
|
expected2[:, 2:6] = 1.0
|
|
np.testing.assert_allclose(out2.numpy(), expected2, rtol=1e-5)
|
|
|
|
# Only dim (start defaults to 0)
|
|
x3 = paddle.zeros((3, 5))
|
|
value3 = paddle.ones((3, 2))
|
|
out3 = paddle.slice_scatter(x3, value3, 1)
|
|
expected3 = np.zeros((3, 5))
|
|
expected3[:, 0:2] = 1.0
|
|
np.testing.assert_allclose(out3.numpy(), expected3, rtol=1e-5)
|
|
|
|
# 2. PyTorch keyword aliases
|
|
out4 = paddle.slice_scatter(
|
|
input=x, src=value, dim=1, start=2, end=6, step=2
|
|
)
|
|
np.testing.assert_allclose(out4.numpy(), expected, rtol=1e-5)
|
|
|
|
# 3. end=None handling (line 1304 branch)
|
|
out5 = paddle.slice_scatter(
|
|
input=x, src=value, dim=1, start=2, end=None, step=2
|
|
)
|
|
np.testing.assert_allclose(out5.numpy(), expected, rtol=1e-5)
|
|
|
|
# Not passing end (line 1359-1368 auto-calc ends)
|
|
out6 = paddle.slice_scatter(input=x, src=value, dim=1, start=2, step=2)
|
|
np.testing.assert_allclose(out6.numpy(), expected, rtol=1e-5)
|
|
|
|
# 4. Paddle style positional args (is_paddle_style=True branch)
|
|
out7 = paddle.slice_scatter(x, value, [1], [2], [6], [2])
|
|
np.testing.assert_allclose(out7.numpy(), expected, rtol=1e-5)
|
|
|
|
# 5. Paddle keyword args
|
|
out8 = paddle.slice_scatter(
|
|
x=x, value=value, axes=[1], starts=[2], ends=[6], strides=[2]
|
|
)
|
|
np.testing.assert_allclose(out8.numpy(), expected, rtol=1e-5)
|
|
|
|
# 6. Tensor method
|
|
out9 = x.slice_scatter(value, dim=1, start=2, end=6, step=2)
|
|
np.testing.assert_allclose(out9.numpy(), expected, rtol=1e-5)
|
|
|
|
# 7. Multi-axis with auto-calc ends
|
|
x_multi = paddle.zeros((3, 3, 5))
|
|
value_multi = paddle.ones((2, 3, 3))
|
|
out_multi = paddle.slice_scatter(
|
|
x_multi, value_multi, axes=[0, 2], starts=[1, 0], strides=[1, 2]
|
|
)
|
|
expected_multi = np.zeros((3, 3, 5))
|
|
expected_multi[1:3, :, 0:5:2] = (
|
|
1.0 # axes=[0,2], starts=[1,0], auto ends
|
|
)
|
|
np.testing.assert_allclose(out_multi.numpy(), expected_multi, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
|
|
np_x = np.zeros((3, 8)).astype("float32")
|
|
np_value = np.ones((3, 2)).astype("float32")
|
|
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(name="x", shape=(3, 8), dtype="float32")
|
|
value = paddle.static.data(
|
|
name="value", shape=(3, 2), dtype="float32"
|
|
)
|
|
|
|
# Paddle style positional args
|
|
out1 = paddle.slice_scatter(x, value, [1], [2], [6], [2])
|
|
# PyTorch keyword args
|
|
out2 = paddle.slice_scatter(
|
|
input=x, src=value, dim=1, start=2, end=6, step=2
|
|
)
|
|
# Tensor method
|
|
out3 = x.slice_scatter(value, [1], [2], [6], [2])
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": np_x, "value": np_value},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
|
|
expected = np.zeros((3, 8))
|
|
expected[:, 2] = 1.0
|
|
expected[:, 4] = 1.0
|
|
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, expected, rtol=1e-5)
|
|
|
|
|
|
# Test tensordot compatibility
|
|
class TestTensordotAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.rand(2, 3).astype("float64")
|
|
self.np_y = np.random.rand(3, 4).astype("float64")
|
|
|
|
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.tensordot(x, y, axes=1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tensordot(x=x, y=y, axes=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.tensordot(a=x, b=y, dims=1)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.tensordot(x, y, axes=1)
|
|
# 5. out parameter test
|
|
out5 = paddle.empty((2, 4), dtype='float64')
|
|
paddle.tensordot(x, y, axes=1, out=out5)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5]:
|
|
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)
|
|
)
|
|
y = paddle.static.data(
|
|
name="y", shape=self.np_y.shape, dtype=str(self.np_y.dtype)
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.tensordot(x, y, axes=1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tensordot(x=x, y=y, axes=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.tensordot(a=x, b=y, dims=1)
|
|
|
|
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
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test tril_indices compatibility
|
|
class TestTrilIndicesAPI(unittest.TestCase):
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.tril_indices(4, 4, 0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tril_indices(row=4, col=4, offset=0)
|
|
# 3. PyTorch keyword arguments (device)
|
|
out3 = paddle.tril_indices(4, 4, 0, device="cpu")
|
|
# 4. Mixed arguments
|
|
out4 = paddle.tril_indices(4, 4, offset=0, device="cpu")
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4]:
|
|
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):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.tril_indices(4, 4, 0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.tril_indices(row=4, col=4, offset=0)
|
|
# 3. PyTorch keyword arguments (device)
|
|
out3 = paddle.tril_indices(4, 4, 0, device="cpu")
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(main, feed={}, fetch_list=[out1, out2, out3])
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test triu_indices compatibility
|
|
class TestTriuIndicesAPI(unittest.TestCase):
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.triu_indices(4, 4, 0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.triu_indices(row=4, col=4, offset=0)
|
|
# 3. PyTorch keyword arguments (device)
|
|
out3 = paddle.triu_indices(4, 4, 0, device="cpu")
|
|
# 4. Mixed arguments
|
|
out4 = paddle.triu_indices(4, 4, offset=0, device="cpu")
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4]:
|
|
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):
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.triu_indices(4, 4, 0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.triu_indices(row=4, col=4, offset=0)
|
|
# 3. PyTorch keyword arguments (device)
|
|
out3 = paddle.triu_indices(4, 4, 0, device="cpu")
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(main, feed={}, fetch_list=[out1, out2, out3])
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test vander compatibility
|
|
class TestVanderAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([1.0, 2.0, 3.0]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
if paddle.is_compiled_with_xpu():
|
|
self.skipTest("vander is not supported on XPU")
|
|
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.vander(x, 3)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.vander(x=x, n=3)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.vander(x, N=3)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.vander(x, n=3, increasing=False)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
if paddle.is_compiled_with_xpu():
|
|
self.skipTest("vander is not supported on XPU")
|
|
|
|
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.vander(x, 3)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.vander(x=x, n=3)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.vander(x, N=3)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test logaddexp compatibility
|
|
class TestLogaddexpAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([-1.0, -2.0, -3.0]).astype("float64")
|
|
self.np_y = np.array([-1.0]).astype("float64")
|
|
|
|
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.logaddexp(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.logaddexp(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.logaddexp(input=x, other=y)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.logaddexp(x, y=y)
|
|
# 5. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
paddle.logaddexp(x, y, out=out5)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5]:
|
|
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)
|
|
)
|
|
y = paddle.static.data(
|
|
name="y", shape=self.np_y.shape, dtype=str(self.np_y.dtype)
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.logaddexp(x, y)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.logaddexp(x=x, y=y)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.logaddexp(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
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test logspace compatibility
|
|
class TestLogspaceAPI(unittest.TestCase):
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.logspace(0, 10, 5, 2)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.logspace(start=0, stop=10, num=5, base=2)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.logspace(0, end=10, steps=5, base=2)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.logspace(0, 10, num=5, base=2)
|
|
# 5. requires_grad parameter test
|
|
out5 = paddle.logspace(0, 10, 5, 2, requires_grad=True)
|
|
self.assertTrue(out1.stop_gradient)
|
|
self.assertFalse(out5.stop_gradient)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_device_param(self):
|
|
"""Test device parameter separately"""
|
|
paddle.disable_static()
|
|
# device parameter test
|
|
out = paddle.logspace(0, 10, 5, base=2, device="cpu")
|
|
self.assertEqual(str(out.place), "Place(cpu)")
|
|
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.logspace(0, 10, 5, 2)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.logspace(start=0, stop=10, num=5, base=2)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.logspace(0, end=10, steps=5, base=2)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(main, feed={}, fetch_list=[out1, out2, out3])
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test moveaxis compatibility
|
|
class TestMoveaxisAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.random.rand(3, 2, 4).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.moveaxis(x, 0, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.moveaxis(x=x, source=0, destination=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.moveaxis(input=x, source=0, destination=1)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.moveaxis(x, source=0, destination=1)
|
|
# 5. Tensor method - args
|
|
out5 = x.moveaxis(0, 1)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5]:
|
|
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.moveaxis(x, 0, 1)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.moveaxis(x=x, source=0, destination=1)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.moveaxis(input=x, source=0, destination=1)
|
|
# 4. Tensor method - args
|
|
out4 = x.moveaxis(0, 1)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test nan_to_num compatibility
|
|
class TestNanToNumAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array(
|
|
[float('nan'), 0.3, float('+inf'), float('-inf')]
|
|
).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.nan_to_num(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.nan_to_num(x=x, nan=0.0, posinf=None, neginf=None)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.nan_to_num(input=x, nan=0.0)
|
|
# 4. Tensor method - args
|
|
out4 = x.nan_to_num()
|
|
|
|
# Verify all outputs (default nan=0, posinf/neginf use large values)
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
# 5. Test with custom nan value separately
|
|
out5 = paddle.nan_to_num(x, nan=1.0)
|
|
expected = np.array(
|
|
[1.0, 0.3, np.finfo(np.float32).max, np.finfo(np.float32).min]
|
|
).astype("float32")
|
|
np.testing.assert_allclose(out5.numpy(), expected, rtol=1e-5)
|
|
|
|
# 6. out parameter test
|
|
out6 = paddle.empty_like(out1)
|
|
paddle.nan_to_num(x, out=out6)
|
|
|
|
# Verify all outputs (default nan=0, posinf/neginf use large values)
|
|
for out in [out1, out2, out3, out4, out6]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
def test_static_Compatibility(self):
|
|
paddle.enable_static()
|
|
main = paddle.static.Program()
|
|
startup = paddle.static.Program()
|
|
with paddle.static.program_guard(main, startup):
|
|
x = paddle.static.data(
|
|
name="x", shape=self.np_x.shape, dtype=str(self.np_x.dtype)
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.nan_to_num(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.nan_to_num(x=x, nan=0.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.nan_to_num(input=x, nan=0.0)
|
|
# 4. Tensor method - args
|
|
out4 = x.nan_to_num()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test nanmean compatibility
|
|
class TestNanmeanAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array(
|
|
[[float('nan'), 0.3, 0.5, 0.9], [0.1, 0.2, float('nan'), 0.7]]
|
|
).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments (no axis - compute mean of all elements)
|
|
out1 = paddle.nanmean(x)
|
|
# 2. Paddle keyword arguments (no axis)
|
|
out2 = paddle.nanmean(x=x)
|
|
# 3. PyTorch keyword arguments (alias, no axis)
|
|
out3 = paddle.nanmean(input=x)
|
|
# 4. Tensor method - args (no axis)
|
|
out4 = x.nanmean()
|
|
|
|
# Verify all outputs (all compute global mean, ignoring nan)
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
# 5. Test with axis separately
|
|
out5 = paddle.nanmean(x, axis=0)
|
|
out6 = paddle.nanmean(input=x, dim=0)
|
|
np.testing.assert_allclose(out5.numpy(), out6.numpy(), rtol=1e-5)
|
|
|
|
# 6. out parameter test
|
|
out7 = paddle.empty_like(out1)
|
|
paddle.nanmean(x, out=out7)
|
|
|
|
# 7. dtype parameter test
|
|
out8 = paddle.nanmean(x, dtype='float64')
|
|
self.assertEqual(out8.dtype, paddle.float64)
|
|
|
|
# Verify all outputs (all compute global mean, ignoring nan)
|
|
for out in [out1, out2, out3, out4, out7]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
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 (no axis)
|
|
out1 = paddle.nanmean(x)
|
|
# 2. Paddle keyword arguments (no axis)
|
|
out2 = paddle.nanmean(x=x)
|
|
# 3. PyTorch keyword arguments (alias, no axis)
|
|
out3 = paddle.nanmean(input=x)
|
|
# 4. Tensor method - args (no axis)
|
|
out4 = x.nanmean()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test nansum compatibility
|
|
class TestNansumAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array(
|
|
[[float('nan'), 0.3, 0.5, 0.9], [0.1, 0.2, float('nan'), 0.7]]
|
|
).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments (no axis - compute sum of all elements)
|
|
out1 = paddle.nansum(x)
|
|
# 2. Paddle keyword arguments (no axis)
|
|
out2 = paddle.nansum(x=x)
|
|
# 3. PyTorch keyword arguments (alias, no axis)
|
|
out3 = paddle.nansum(input=x)
|
|
# 4. Tensor method - args (no axis)
|
|
out4 = x.nansum()
|
|
|
|
# Verify all outputs (all compute global sum, ignoring nan)
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), out1.numpy(), rtol=1e-5)
|
|
|
|
# 5. Test with axis separately
|
|
out5 = paddle.nansum(x, axis=0)
|
|
out6 = paddle.nansum(input=x, dim=0)
|
|
np.testing.assert_allclose(out5.numpy(), out6.numpy(), rtol=1e-5)
|
|
|
|
# 6. out parameter test
|
|
out7 = paddle.empty_like(out1)
|
|
paddle.nansum(x, out=out7)
|
|
|
|
# 7. dtype parameter test
|
|
out8 = paddle.nansum(x, dtype='float64')
|
|
self.assertEqual(out8.dtype, paddle.float64)
|
|
|
|
# Verify all outputs (all compute global sum, ignoring nan)
|
|
for out in [out1, out2, out3, out4, out7]:
|
|
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 (no axis)
|
|
out1 = paddle.nansum(x)
|
|
# 2. Paddle keyword arguments (no axis)
|
|
out2 = paddle.nansum(x=x)
|
|
# 3. PyTorch keyword arguments (alias, no axis)
|
|
out3 = paddle.nansum(input=x)
|
|
# 4. Tensor method - args (no axis)
|
|
out4 = x.nansum()
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test masked_fill compatibility
|
|
class TestMaskedFillAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.ones((3, 3)).astype("float32")
|
|
self.np_mask = np.array([[True, True, False]]).astype("bool")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
mask = paddle.to_tensor(self.np_mask)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.masked_fill(x, mask, 2.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.masked_fill(x=x, mask=mask, value=2.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.masked_fill(input=x, mask=mask, value=2.0)
|
|
# 4. Mixed arguments
|
|
out4 = paddle.masked_fill(x, mask, value=2.0)
|
|
# 5. Tensor method - args
|
|
out5 = x.masked_fill(mask, 2.0)
|
|
|
|
# Verify all outputs
|
|
for out in [out1, out2, out3, out4, out5]:
|
|
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)
|
|
)
|
|
mask = paddle.static.data(
|
|
name="mask",
|
|
shape=self.np_mask.shape,
|
|
dtype=str(self.np_mask.dtype),
|
|
)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.masked_fill(x, mask, 2.0)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.masked_fill(x=x, mask=mask, value=2.0)
|
|
# 3. PyTorch keyword arguments (alias)
|
|
out3 = paddle.masked_fill(input=x, mask=mask, value=2.0)
|
|
# 4. Tensor method - args
|
|
out4 = x.masked_fill(mask, 2.0)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x, "mask": self.np_mask},
|
|
fetch_list=[out1, out2, out3, out4],
|
|
)
|
|
|
|
# Verify all outputs
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, fetches[0], rtol=1e-5)
|
|
|
|
|
|
# Test addmv compatibility
|
|
class TestAddmvAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3).astype("float32")
|
|
self.np_mat = np.random.rand(3, 4).astype("float32")
|
|
self.np_vec = np.random.rand(4).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
mat = paddle.to_tensor(self.np_mat)
|
|
vec = paddle.to_tensor(self.np_vec)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.addmv(input, mat, vec)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.addmv(input=input, mat=mat, vec=vec)
|
|
# 3. With beta and alpha
|
|
out3 = paddle.addmv(input, mat, vec, beta=0.5, alpha=2.0)
|
|
# 4. Tensor method
|
|
out4 = input.addmv(mat, vec)
|
|
# 5. Tensor method with kwargs
|
|
out5 = input.addmv(mat=mat, vec=vec, beta=0.5, alpha=2.0)
|
|
# 6. out parameter test
|
|
out6 = paddle.empty_like(out1)
|
|
paddle.addmv(input, mat, vec, out=out6)
|
|
|
|
# Verify outputs
|
|
expected = 1.0 * self.np_input + 1.0 * np.dot(self.np_mat, self.np_vec)
|
|
for out in [out1, out2, out4, 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):
|
|
input = paddle.static.data(
|
|
name="input",
|
|
shape=self.np_input.shape,
|
|
dtype=str(self.np_input.dtype),
|
|
)
|
|
mat = paddle.static.data(
|
|
name="mat",
|
|
shape=self.np_mat.shape,
|
|
dtype=str(self.np_mat.dtype),
|
|
)
|
|
vec = paddle.static.data(
|
|
name="vec",
|
|
shape=self.np_vec.shape,
|
|
dtype=str(self.np_vec.dtype),
|
|
)
|
|
|
|
out1 = paddle.addmv(input, mat, vec)
|
|
out2 = paddle.addmv(input=input, mat=mat, vec=vec)
|
|
out3 = input.addmv(mat, vec)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={
|
|
"input": self.np_input,
|
|
"mat": self.np_mat,
|
|
"vec": self.np_vec,
|
|
},
|
|
fetch_list=[out1, out2, out3],
|
|
)
|
|
|
|
expected = 1.0 * self.np_input + 1.0 * np.dot(
|
|
self.np_mat, self.np_vec
|
|
)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, expected, rtol=1e-5)
|
|
|
|
|
|
# Test addmv_ compatibility (inplace)
|
|
class TestAddmv_InplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3).astype("float32")
|
|
self.np_mat = np.random.rand(3, 4).astype("float32")
|
|
self.np_vec = np.random.rand(4).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input.copy())
|
|
mat = paddle.to_tensor(self.np_mat)
|
|
vec = paddle.to_tensor(self.np_vec)
|
|
|
|
# Inplace operation
|
|
input.addmv_(mat, vec)
|
|
|
|
expected = 1.0 * self.np_input + 1.0 * np.dot(self.np_mat, self.np_vec)
|
|
np.testing.assert_allclose(input.numpy(), expected, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test addr compatibility
|
|
class TestAddrAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3, 4).astype("float32")
|
|
self.np_vec1 = np.random.rand(3).astype("float32")
|
|
self.np_vec2 = np.random.rand(4).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input)
|
|
vec1 = paddle.to_tensor(self.np_vec1)
|
|
vec2 = paddle.to_tensor(self.np_vec2)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.addr(input, vec1, vec2)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.addr(input=input, vec1=vec1, vec2=vec2)
|
|
# 3. With beta and alpha
|
|
out3 = paddle.addr(input, vec1, vec2, beta=0.5, alpha=2.0)
|
|
# 4. Tensor method
|
|
out4 = input.addr(vec1, vec2)
|
|
# 5. out parameter test
|
|
out5 = paddle.empty_like(out1)
|
|
paddle.addr(input, vec1, vec2, out=out5)
|
|
|
|
# Verify outputs
|
|
expected = 1.0 * self.np_input + 1.0 * np.outer(
|
|
self.np_vec1, self.np_vec2
|
|
)
|
|
for out in [out1, out2, out4, out5]:
|
|
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):
|
|
input = paddle.static.data(
|
|
name="input",
|
|
shape=self.np_input.shape,
|
|
dtype=str(self.np_input.dtype),
|
|
)
|
|
vec1 = paddle.static.data(
|
|
name="vec1",
|
|
shape=self.np_vec1.shape,
|
|
dtype=str(self.np_vec1.dtype),
|
|
)
|
|
vec2 = paddle.static.data(
|
|
name="vec2",
|
|
shape=self.np_vec2.shape,
|
|
dtype=str(self.np_vec2.dtype),
|
|
)
|
|
|
|
out1 = paddle.addr(input, vec1, vec2)
|
|
out2 = input.addr(vec1, vec2)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={
|
|
"input": self.np_input,
|
|
"vec1": self.np_vec1,
|
|
"vec2": self.np_vec2,
|
|
},
|
|
fetch_list=[out1, out2],
|
|
)
|
|
|
|
expected = 1.0 * self.np_input + 1.0 * np.outer(
|
|
self.np_vec1, self.np_vec2
|
|
)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, expected, rtol=1e-5)
|
|
|
|
|
|
# Test addr_ compatibility (inplace)
|
|
class TestAddr_InplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_input = np.random.rand(3, 4).astype("float32")
|
|
self.np_vec1 = np.random.rand(3).astype("float32")
|
|
self.np_vec2 = np.random.rand(4).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
input = paddle.to_tensor(self.np_input.copy())
|
|
vec1 = paddle.to_tensor(self.np_vec1)
|
|
vec2 = paddle.to_tensor(self.np_vec2)
|
|
|
|
# Inplace operation
|
|
input.addr_(vec1, vec2)
|
|
|
|
expected = 1.0 * self.np_input + 1.0 * np.outer(
|
|
self.np_vec1, self.np_vec2
|
|
)
|
|
np.testing.assert_allclose(input.numpy(), expected, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test trunc compatibility (with out parameter)
|
|
class TestTruncAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([1.5, -2.7, 0.3, -0.8]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.trunc(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.trunc(input=x)
|
|
# 3. out parameter
|
|
out3 = paddle.empty_like(x)
|
|
paddle.trunc(x, out=out3)
|
|
|
|
# Verify outputs
|
|
expected = np.trunc(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)
|
|
)
|
|
|
|
out1 = paddle.trunc(x)
|
|
out2 = paddle.trunc(input=x)
|
|
|
|
exe = paddle.static.Executor()
|
|
fetches = exe.run(
|
|
main,
|
|
feed={"x": self.np_x},
|
|
fetch_list=[out1, out2],
|
|
)
|
|
|
|
expected = np.trunc(self.np_x)
|
|
for out in fetches:
|
|
np.testing.assert_allclose(out, expected, rtol=1e-5)
|
|
|
|
|
|
# Test fix compatibility (alias for trunc)
|
|
class TestFixAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([1.5, -2.7, 0.3, -0.8]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x)
|
|
|
|
# 1. Paddle Positional arguments
|
|
out1 = paddle.fix(x)
|
|
# 2. Paddle keyword arguments
|
|
out2 = paddle.fix(input=x)
|
|
# 3. out parameter
|
|
out3 = paddle.empty_like(x)
|
|
paddle.fix(x, out=out3)
|
|
# 4. Tensor method
|
|
out4 = x.fix()
|
|
|
|
# Verify outputs (fix is alias for trunc)
|
|
expected = np.trunc(self.np_x)
|
|
for out in [out1, out2, out3, out4]:
|
|
np.testing.assert_allclose(out.numpy(), expected, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
# Test fix_ compatibility (inplace alias for trunc_)
|
|
class TestFix_InplaceAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(2025)
|
|
self.np_x = np.array([1.5, -2.7, 0.3, -0.8]).astype("float32")
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
x = paddle.to_tensor(self.np_x.copy())
|
|
|
|
# Inplace operation
|
|
x.fix_()
|
|
|
|
expected = np.trunc(self.np_x)
|
|
np.testing.assert_allclose(x.numpy(), expected, rtol=1e-5)
|
|
|
|
paddle.enable_static()
|
|
|
|
|
|
class RandomDataset(paddle.utils.data.Dataset):
|
|
def __init__(self, num_samples):
|
|
self.num_samples = num_samples
|
|
|
|
def __getitem__(self, idx):
|
|
image = np.random.random([784]).astype('float32')
|
|
label = np.random.randint(0, 10 - 1, (1,)).astype('int64')
|
|
return image, label
|
|
|
|
def __len__(self):
|
|
return self.num_samples
|
|
|
|
|
|
class TestDataLoaderAPI(unittest.TestCase):
|
|
def setUp(self):
|
|
np.random.seed(255)
|
|
self.batch_num = 4
|
|
self.batch_size = 8
|
|
self.dataset = RandomDataset(self.batch_num * self.batch_size)
|
|
self.batch_sampler = paddle.utils.data.BatchSampler(
|
|
self.dataset,
|
|
batch_size=self.batch_size,
|
|
shuffle=True,
|
|
drop_last=True,
|
|
)
|
|
|
|
def iter_loader_data(self, loader):
|
|
for _ in range(3):
|
|
for image, label in loader():
|
|
relu = paddle.nn.functional.relu(image)
|
|
self.assertEqual(image.shape, [self.batch_size, 784])
|
|
self.assertEqual(label.shape, [self.batch_size, 1])
|
|
self.assertEqual(relu.shape, [self.batch_size, 784])
|
|
|
|
def test_dygraph_Compatibility(self):
|
|
paddle.disable_static()
|
|
# case 1
|
|
loader = paddle.utils.data.DataLoader(
|
|
self.dataset,
|
|
self.batch_size,
|
|
shuffle=True,
|
|
num_workers=0,
|
|
drop_last=True,
|
|
)
|
|
self.iter_loader_data(loader)
|
|
# case 2
|
|
loader = paddle.utils.data.dataloader.DataLoader(
|
|
dataset=self.dataset,
|
|
batch_sampler=self.batch_sampler,
|
|
)
|
|
self.iter_loader_data(loader)
|
|
# case 3
|
|
loader = paddle.utils.data.DataLoader(
|
|
dataset=self.dataset,
|
|
sampler=self.batch_sampler,
|
|
)
|
|
self.iter_loader_data(loader)
|
|
paddle.enable_static()
|
|
|
|
def test_error(self):
|
|
paddle.disable_static()
|
|
with self.assertRaises(ValueError):
|
|
loader = paddle.utils.data.dataloader.DataLoader(
|
|
dataset=self.dataset,
|
|
sampler=self.batch_sampler,
|
|
batch_sampler=self.batch_sampler,
|
|
)
|
|
paddle.enable_static()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|