paddlepaddle--paddle
wehub-resource-sync
1098 行
46 KiB
Python
1098 行
46 KiB
Python
# Copyright (c) 2023 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 inspect
|
|
import unittest
|
|
import warnings
|
|
|
|
import numpy as np
|
|
from op_test import get_device, is_custom_device
|
|
from utils import dygraph_guard, static_guard
|
|
|
|
import paddle
|
|
from paddle import base
|
|
|
|
paddle.enable_static()
|
|
paddle.device.set_device("cpu")
|
|
|
|
|
|
def new_program():
|
|
# TODO(gouzil): Optimize program code
|
|
main_program = paddle.static.Program()
|
|
startup_program = paddle.static.Program()
|
|
place = paddle.CPUPlace()
|
|
exe = base.Executor(place)
|
|
return (
|
|
main_program,
|
|
exe,
|
|
paddle.static.program_guard(
|
|
main_program=main_program, startup_program=startup_program
|
|
),
|
|
)
|
|
|
|
|
|
class TestMathOpPatchesPir(unittest.TestCase):
|
|
def test_pow(self):
|
|
# Calculate results in dynamic graphs
|
|
paddle.disable_static()
|
|
x_np = np.random.random([10, 1024]).astype('float32')
|
|
y_np = np.random.random([10, 1024]).astype('float32')
|
|
res_np_b = x_np**y_np
|
|
res_np_c = paddle.pow(paddle.to_tensor(x_np), 2)
|
|
res_np_d = x_np.__pow__(2)
|
|
res_np_e = x_np.__rpow__(2)
|
|
paddle.enable_static()
|
|
# Calculate results under pir
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype='float32'
|
|
)
|
|
y = paddle.static.data(
|
|
name='y', shape=[10, 1024], dtype='float32'
|
|
)
|
|
b = x**y
|
|
c = x.pow(2)
|
|
d = x.__pow__(2)
|
|
e = x.__rpow__(2)
|
|
# TODO(gouzil): Why not use `paddle.static.default_main_program()`？
|
|
# Because different case do not isolate parameters (This is a known problem)
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_allclose(res_np_b, b_np, rtol=1e-05)
|
|
np.testing.assert_allclose(res_np_c, c_np, rtol=1e-05)
|
|
np.testing.assert_allclose(res_np_d, d_np, rtol=1e-05)
|
|
np.testing.assert_allclose(res_np_e, e_np, rtol=1e-05)
|
|
|
|
def test_mod(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.randint(1, 100, size=[10, 1024], dtype=np.int64)
|
|
y_np = np.random.randint(1, 100, size=[10, 1024], dtype=np.int64)
|
|
res_np_b = x_np % y_np
|
|
res_np_c = paddle.mod(paddle.to_tensor(x_np), paddle.to_tensor(y_np))
|
|
res_np_d = x_np.__mod__(y_np)
|
|
res_np_e = x_np.__rmod__(y_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype='int64'
|
|
)
|
|
y = paddle.static.data(
|
|
name='y', shape=[10, 1024], dtype='int64'
|
|
)
|
|
b = x % y
|
|
c = x.mod(y)
|
|
d = x.__mod__(y)
|
|
e = x.__rmod__(y)
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_allclose(res_np_b, b_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_c, c_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_d, d_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_e, e_np, rtol=1e-05)
|
|
|
|
def test_matmul(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.uniform(-1, 1, [2, 3]).astype('float32')
|
|
y_np = np.random.uniform(-1, 1, [3, 5]).astype('float32')
|
|
res_np_b = x_np @ y_np # __matmul__
|
|
res_np_c = paddle.matmul(paddle.to_tensor(x_np), paddle.to_tensor(y_np))
|
|
res_np_d = x_np.__matmul__(y_np)
|
|
res_np_e = y_np.__rmatmul__(x_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name='x', shape=[2, 3], dtype='float32')
|
|
y = paddle.static.data(name='y', shape=[3, 5], dtype='float32')
|
|
b = x @ y
|
|
c = x.matmul(y)
|
|
d = x.__matmul__(y)
|
|
e = y.__rmatmul__(x)
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_allclose(res_np_b, b_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_c, c_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_d, d_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_e, e_np, atol=1e-05)
|
|
|
|
def test_floordiv(self):
|
|
paddle.disable_static()
|
|
x_np = np.full([10, 1024], 10, np.int64)
|
|
y_np = np.full([10, 1024], 2, np.int64)
|
|
res_np_b = x_np // y_np
|
|
res_np_c = paddle.floor_divide(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_d = x_np.__floordiv__(y_np)
|
|
res_np_e = x_np.__rfloordiv__(y_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype='int64'
|
|
)
|
|
y = paddle.static.data(
|
|
name='y', shape=[10, 1024], dtype='int64'
|
|
)
|
|
b = x // y
|
|
c = x.floor_divide(y)
|
|
d = x.__floordiv__(y)
|
|
e = x.__rfloordiv__(y)
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_allclose(res_np_b, b_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_c, c_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_d, d_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_e, e_np, rtol=1e-05)
|
|
|
|
def test_bitwise_not(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
res_np_b = ~x_np
|
|
res_np_c = paddle.bitwise_not(paddle.to_tensor(x_np))
|
|
res_np_d = x_np.__invert__()
|
|
res_np_e = res_np_d
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name='x', shape=[2, 3, 5], dtype='int32')
|
|
b = ~x
|
|
c = x.bitwise_not()
|
|
d = x.__invert__()
|
|
e = x.bitwise_invert()
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
np.testing.assert_array_equal(res_np_e, e_np)
|
|
|
|
def test_bitwise_xor(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
res_np_b = x_np ^ y_np
|
|
res_np_c = paddle.bitwise_xor(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_d = x_np.__xor__(y_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[2, 3, 5], dtype="int32")
|
|
y = paddle.static.data(name="y", shape=[2, 3, 5], dtype="int32")
|
|
b = x ^ y
|
|
c = x.bitwise_xor(y)
|
|
d = x.__xor__(y)
|
|
(b_np, c_np, d_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
|
|
def test_rxor(self):
|
|
with dygraph_guard():
|
|
x_int32 = 5
|
|
x_bool = True
|
|
y_np = np.random.randint(0, 2, [2, 3, 5]).astype("int32")
|
|
y_tensor = paddle.to_tensor(y_np)
|
|
res_ror_int32 = x_int32 ^ y_tensor
|
|
res_py_int32 = x_int32 ^ y_tensor.numpy()
|
|
np.testing.assert_array_equal(res_py_int32, res_ror_int32.numpy())
|
|
res_ror_bool = x_bool ^ y_tensor
|
|
res_py_bool = x_bool ^ y_tensor.numpy()
|
|
np.testing.assert_array_equal(res_py_bool, res_ror_bool.numpy())
|
|
for x_np in (
|
|
np.float32(5.0),
|
|
np.float64(5.0),
|
|
np.complex64(5),
|
|
np.complex128(5.0 + 2j),
|
|
):
|
|
with self.assertRaises(TypeError):
|
|
x_np ^ y_tensor
|
|
|
|
with (
|
|
static_guard(),
|
|
paddle.pir_utils.IrGuard(),
|
|
):
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x_int = 5
|
|
y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
y = paddle.static.data("y", y_np.shape, dtype=y_np.dtype)
|
|
z = x_int ^ y
|
|
out = exe.run(
|
|
main_program,
|
|
feed={'y': y_np},
|
|
fetch_list=[z],
|
|
)
|
|
out_ref = x_int ^ y_np
|
|
np.testing.assert_array_equal(out[0], out_ref)
|
|
x_bool = True
|
|
res_rxor_bool = x_bool ^ y
|
|
out_bool = exe.run(
|
|
main_program,
|
|
feed={'y': y_np},
|
|
fetch_list=[res_rxor_bool],
|
|
)
|
|
res_py_bool = x_bool ^ y_np
|
|
np.testing.assert_array_equal(out_bool[0], res_py_bool)
|
|
|
|
for x_invalid in (
|
|
np.float32(5.0),
|
|
np.float64(5.0),
|
|
np.complex64(5),
|
|
np.complex128(5.0 + 2j),
|
|
):
|
|
with self.assertRaises(TypeError):
|
|
x_invalid ^ y
|
|
|
|
def test_bitwise_or(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
res_np_b = x_np | y_np
|
|
res_np_c = paddle.bitwise_or(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_d = x_np.__or__(y_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[2, 3, 5], dtype="int32")
|
|
y = paddle.static.data(name="y", shape=[2, 3, 5], dtype="int32")
|
|
b = x | y
|
|
c = x.bitwise_or(y)
|
|
d = x.__or__(y)
|
|
(b_np, c_np, d_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
|
|
def test_ror(self):
|
|
with dygraph_guard():
|
|
x_int32 = 5
|
|
x_bool = True
|
|
y_np = np.random.randint(0, 2, [2, 3, 5]).astype("int32")
|
|
y_tensor = paddle.to_tensor(y_np)
|
|
res_ror_int32 = x_int32 | y_tensor
|
|
res_py_int32 = x_int32 | y_tensor.numpy()
|
|
np.testing.assert_array_equal(res_py_int32, res_ror_int32.numpy())
|
|
res_ror_bool = x_bool | y_tensor
|
|
res_py_bool = x_bool | y_tensor.numpy()
|
|
np.testing.assert_array_equal(res_py_bool, res_ror_bool.numpy())
|
|
for x_np in (
|
|
np.float32(5.0),
|
|
np.float64(5.0),
|
|
np.complex64(5),
|
|
np.complex128(5.0 + 2j),
|
|
):
|
|
with self.assertRaises(TypeError):
|
|
x_np | y_tensor
|
|
|
|
with (
|
|
static_guard(),
|
|
paddle.pir_utils.IrGuard(),
|
|
):
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x_int = 5
|
|
y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
y = paddle.static.data("y", y_np.shape, dtype=y_np.dtype)
|
|
z = x_int | y
|
|
out = exe.run(
|
|
main_program,
|
|
feed={'y': y_np},
|
|
fetch_list=[z],
|
|
)
|
|
out_ref = x_int | y_np
|
|
np.testing.assert_array_equal(out[0], out_ref)
|
|
x_bool = True
|
|
res_ror_bool = x_bool | y
|
|
out_bool = exe.run(
|
|
main_program,
|
|
feed={'y': y_np},
|
|
fetch_list=[res_ror_bool],
|
|
)
|
|
res_py_bool = x_bool | y_np
|
|
np.testing.assert_array_equal(out_bool[0], res_py_bool)
|
|
|
|
for x_invalid in (
|
|
np.float32(5.0),
|
|
np.float64(5.0),
|
|
np.complex64(5),
|
|
np.complex128(5.0 + 2j),
|
|
):
|
|
with self.assertRaises(TypeError):
|
|
x_invalid | y
|
|
|
|
def test_bitwise_and(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
|
|
res_np_b = x_np & y_np
|
|
res_np_c = paddle.bitwise_and(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_d = x_np.__and__(y_np)
|
|
temp = 2
|
|
res_np_e = temp & y_np
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[2, 3, 5], dtype="int32")
|
|
y = paddle.static.data(name="y", shape=[2, 3, 5], dtype="int32")
|
|
b = x & y
|
|
c = x.bitwise_and(y)
|
|
d = x.__and__(y)
|
|
e = temp & y
|
|
(b_np, c_np, d_np, e_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[b, c, d, e],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
np.testing.assert_array_equal(res_np_e, e_np)
|
|
|
|
def test_positive(self):
|
|
paddle.disable_static()
|
|
x_np = np.random.random([10, 1024]).astype('float32')
|
|
res_np_b = +x_np
|
|
res_np_c = paddle.positive(paddle.to_tensor(x_np))
|
|
res_np_d = x_np.__pos__()
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype='float32'
|
|
)
|
|
b = +x
|
|
c = paddle.positive(x)
|
|
d = x.__pos__()
|
|
(b_np, c_np, d_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[b, c, d],
|
|
)
|
|
np.testing.assert_allclose(res_np_b, b_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_c, c_np, atol=1e-05)
|
|
np.testing.assert_allclose(res_np_d, d_np, atol=1e-05)
|
|
|
|
# for logical compare
|
|
def test_equal_and_nequal(self):
|
|
def _test(x_np, y_np, input_dtype):
|
|
paddle.disable_static()
|
|
# TODO(gouzil): Open after deleting c++ logic
|
|
# res_np_b = x_np == y_np
|
|
# res_np_c = paddle.equal(paddle.to_tensor(x_np), paddle.to_tensor(y_np))
|
|
# res_np_d = x_np.__eq__(y_np)
|
|
res_np_e = x_np != y_np
|
|
res_np_f = paddle.not_equal(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_g = x_np.__ne__(y_np)
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name="x", shape=[-1, 1], dtype=input_dtype
|
|
)
|
|
y = paddle.static.data(
|
|
name="y", shape=[-1, 1], dtype=input_dtype
|
|
)
|
|
# b = x == y
|
|
# c = x.equal(y)
|
|
# d = x.__eq__(y)
|
|
e = x != y
|
|
f = x.not_equal(y)
|
|
g = x.__ne__(y)
|
|
self.assertFalse(x == None) # noqa: E711
|
|
self.assertTrue(x != None) # noqa: E711
|
|
(e_np, f_np, g_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np},
|
|
fetch_list=[e, f, g],
|
|
)
|
|
# np.testing.assert_array_equal(res_np_b, b_np)
|
|
# np.testing.assert_array_equal(res_np_c, c_np)
|
|
# np.testing.assert_array_equal(res_np_d, d_np)
|
|
np.testing.assert_array_equal(res_np_e, e_np)
|
|
np.testing.assert_array_equal(res_np_f, f_np)
|
|
np.testing.assert_array_equal(res_np_g, g_np)
|
|
|
|
x_np_1 = np.array([3, 4, 10, 14, 9, 18]).astype('float32')
|
|
y_np_2 = np.array([3, 4, 11, 15, 8, 18]).astype('float32')
|
|
|
|
x_np_3 = np.random.rand(0).astype("complex64")
|
|
y_np_4 = 4 + 5j
|
|
|
|
_test(x_np_1, y_np_2, 'float32')
|
|
_test(x_np_3, y_np_4, 'complex64')
|
|
|
|
def test_less(self):
|
|
paddle.disable_static()
|
|
x_np = np.array([3, 4, 10, 14, 9, 18]).astype('float32')
|
|
y_np = np.array([3, 4, 11, 15, 8, 18]).astype('float32')
|
|
z_np = np.array([3, 4, 10, 14, 9, 18]).astype('float32')
|
|
res_np_b = x_np < y_np
|
|
res_np_c = paddle.less_than(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_c_ = paddle.less(paddle.to_tensor(x_np), paddle.to_tensor(y_np))
|
|
res_np_d = x_np.__lt__(y_np)
|
|
res_np_e = x_np <= y_np
|
|
res_np_f = paddle.less_equal(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_g = x_np.__le__(y_np)
|
|
res_np_h = x_np <= z_np
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[-1, 1], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[-1, 1], dtype='float32')
|
|
z = paddle.static.data(name="z", shape=[-1, 1], dtype='float32')
|
|
b = x < y
|
|
c = x.less_than(y)
|
|
c_ = x.less(y)
|
|
d = x.__lt__(y)
|
|
e = x <= y
|
|
f = x.less_equal(y)
|
|
g = x.__le__(y)
|
|
h = x <= z
|
|
(b_np, c_np, c_np_, d_np, e_np, f_np, g_np, h_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np, "z": z_np},
|
|
fetch_list=[b, c, c_, d, e, f, g, h],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_c_, c_np_)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
np.testing.assert_array_equal(res_np_e, e_np)
|
|
np.testing.assert_array_equal(res_np_f, f_np)
|
|
np.testing.assert_array_equal(res_np_g, g_np)
|
|
np.testing.assert_array_equal(res_np_h, h_np)
|
|
|
|
def test_greater(self):
|
|
paddle.disable_static()
|
|
x_np = np.array([3, 4, 10, 14, 9, 18]).astype('float32')
|
|
y_np = np.array([3, 4, 11, 15, 8, 18]).astype('float32')
|
|
z_np = np.array([3, 4, 10, 14, 9, 18]).astype('float32')
|
|
res_np_b = x_np > y_np
|
|
res_np_c = paddle.greater_than(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_d = x_np.__gt__(y_np)
|
|
res_np_e = x_np >= y_np
|
|
res_np_f = paddle.greater_equal(
|
|
paddle.to_tensor(x_np), paddle.to_tensor(y_np)
|
|
)
|
|
res_np_g = x_np.__ge__(y_np)
|
|
res_np_h = x_np >= z_np
|
|
paddle.enable_static()
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[-1, 1], dtype='float32')
|
|
y = paddle.static.data(name="y", shape=[-1, 1], dtype='float32')
|
|
z = paddle.static.data(name="z", shape=[-1, 1], dtype='float32')
|
|
b = x > y
|
|
c = x.greater_than(y)
|
|
d = x.__gt__(y)
|
|
e = x >= y
|
|
f = x.greater_equal(y)
|
|
g = x.__ge__(y)
|
|
h = x >= z
|
|
(b_np, c_np, d_np, e_np, f_np, g_np, h_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np, "z": z_np},
|
|
fetch_list=[b, c, d, e, f, g, h],
|
|
)
|
|
np.testing.assert_array_equal(res_np_b, b_np)
|
|
np.testing.assert_array_equal(res_np_c, c_np)
|
|
np.testing.assert_array_equal(res_np_d, d_np)
|
|
np.testing.assert_array_equal(res_np_e, e_np)
|
|
np.testing.assert_array_equal(res_np_f, f_np)
|
|
np.testing.assert_array_equal(res_np_g, g_np)
|
|
np.testing.assert_array_equal(res_np_h, h_np)
|
|
|
|
def test_item(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
y = paddle.static.data(name='y', shape=[1])
|
|
with self.assertRaises(ValueError):
|
|
x.item()
|
|
|
|
def test_place(self):
|
|
with warnings.catch_warnings(record=True) as w:
|
|
warnings.simplefilter("always")
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
_ = x.place
|
|
self.assertTrue(len(w) == 1)
|
|
self.assertTrue("place" in str(w[-1].message))
|
|
|
|
def test_cpu(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
x.cpu()
|
|
|
|
def test_cuda(self):
|
|
if base.is_compiled_with_cuda() or is_custom_device():
|
|
paddle.device.set_device(get_device())
|
|
with warnings.catch_warnings(record=True) as w:
|
|
warnings.simplefilter("always")
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
x.cpu()
|
|
x.cuda(1, False)
|
|
self.assertTrue(len(w) == 2)
|
|
self.assertTrue(
|
|
"device_id is not supported" in str(w[-2].message)
|
|
)
|
|
self.assertTrue(
|
|
"blocking is not supported" in str(w[-1].message)
|
|
)
|
|
paddle.device.set_device("cpu")
|
|
|
|
def test_some_dim(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
self.assertEqual(x.dim(), 3)
|
|
self.assertEqual(x.ndimension(), 3)
|
|
self.assertEqual(x.ndim, 3)
|
|
|
|
def test_size(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.assign(np.random.rand(2, 3, 4).astype("float32"))
|
|
(output_x,) = exe.run(main_program, fetch_list=[x.size])
|
|
self.assertEqual(output_x, 24)
|
|
|
|
def test_T(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
for ndim in range(5):
|
|
# shape is [], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4]
|
|
shape = list(range(1, ndim + 1))
|
|
out_shape = list(reversed(shape))
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_T = x.T
|
|
self.assertEqual(x_T.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_T])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
def test_astype_zero_copy_if_same_dtype(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
x = paddle.static.data(name='x', shape=[3, 2, 1])
|
|
y = x.astype(x.dtype)
|
|
self.assertTrue(x.is_same(y))
|
|
|
|
def test_mT(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
shape = [1]
|
|
x = paddle.rand(shape, dtype="float32")
|
|
self.assertRaises(ValueError, getattr, x, 'mT')
|
|
|
|
for ndim in range(2, 5):
|
|
# shape is [1, 2], [1, 2, 3], [1, 2, 3, 4]
|
|
shape = list(range(1, ndim + 1))
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_mT = x.mT
|
|
self.assertEqual(x_mT.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_mT])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
shape = [1, 2, 3, 0, 1]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_mT = x.mT
|
|
self.assertEqual(x_mT.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_mT])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
shape = [1, 2, 3, 1, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_mT = x.mT
|
|
self.assertEqual(x_mT.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_mT])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
shape = [1, 2, 3, 0, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_mT = x.mT
|
|
self.assertEqual(x_mT.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_mT])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
shape = [0, 2, 3, 0, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_mT = x.mT
|
|
self.assertEqual(x_mT.shape, out_shape)
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_mT])
|
|
self.assertEqual(output_x.shape, tuple(out_shape))
|
|
|
|
# test mT with dynamic shape
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[-1, 5], dtype='float32')
|
|
y = paddle.static.data(
|
|
name="y", shape=[2, -1, -1], dtype='float32'
|
|
)
|
|
z = paddle.static.data(
|
|
name="z", shape=[-1, 5, -1, -1], dtype='float32'
|
|
)
|
|
x_mT = x.mT
|
|
y_mT = y.mT
|
|
z_mT = z.mT
|
|
|
|
x_np = np.random.randn(12, 5).astype('float32')
|
|
y_np = np.random.randn(2, 3, 4).astype('float32')
|
|
z_np = np.random.randn(100, 5, 12, 13).astype('float32')
|
|
(x_mT_np, y_mT_np, z_mT_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np, "y": y_np, "z": z_np},
|
|
fetch_list=[x_mT, y_mT, z_mT],
|
|
)
|
|
np.testing.assert_array_equal(x_mT_np.shape, (5, 12))
|
|
np.testing.assert_array_equal(y_mT_np.shape, (2, 4, 3))
|
|
np.testing.assert_array_equal(z_mT_np.shape, (100, 5, 13, 12))
|
|
|
|
def test_new_xxx(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
shape = [1]
|
|
x = paddle.rand(shape, dtype="float32")
|
|
self.assertRaises(ValueError, getattr, x, 'mT')
|
|
|
|
for ndim in range(2, 5):
|
|
# shape is [1, 2], [1, 2, 3], [1, 2, 3, 4]
|
|
shape = list(range(1, ndim + 1))
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_new = x.new_full([7], 1.0)
|
|
self.assertEqual(x_new.shape, [7])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (7,))
|
|
|
|
shape = [1, 2, 3, 0, 1]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_new = x.new_full([3, 0], 4.0)
|
|
self.assertEqual(x_new.shape, [3, 0])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (3, 0))
|
|
|
|
shape = [1, 2, 3, 1, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_new = x.new_empty([2, 2])
|
|
self.assertEqual(x_new.shape, [2, 2])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (2, 2))
|
|
|
|
shape = [1, 2, 3, 0, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_new = x.new_ones([2, 2])
|
|
self.assertEqual(x_new.shape, [2, 2])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (2, 2))
|
|
|
|
shape = [0, 2, 3, 0, 0]
|
|
out_shape = list(shape)
|
|
out_shape[-2], out_shape[-1] = out_shape[-1], out_shape[-2]
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.rand(shape, dtype="float32")
|
|
x_new = x.new_zeros([2, 3])
|
|
self.assertEqual(x_new.shape, [2, 3])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (2, 3))
|
|
|
|
x_new = x.new_zeros(2, 3)
|
|
self.assertEqual(x_new.shape, [2, 3])
|
|
(output_x,) = exe.run(main_program, fetch_list=[x_new])
|
|
self.assertEqual(output_x.shape, (2, 3))
|
|
|
|
# test mT with dynamic shape
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name="x", shape=[-1, 5], dtype='float32')
|
|
x_new = x.new_ones([2, 2])
|
|
|
|
x_np = np.random.randn(12, 5).astype('float32')
|
|
(x_new_np,) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[x_new],
|
|
)
|
|
np.testing.assert_array_equal(x_new_np.shape, (2, 2))
|
|
|
|
def test_hash(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
_, _, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data('x', [2, 3])
|
|
self.assertEqual(hash(x), hash(id(x)))
|
|
|
|
def test_clone(self):
|
|
x_np = np.random.random(size=[100, 10]).astype('float64')
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[100, 10], dtype="float64"
|
|
)
|
|
a = x.clone()
|
|
(a_np,) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[a],
|
|
)
|
|
np.testing.assert_array_equal(x_np, a_np)
|
|
self.assertNotEqual(id(x), id(a))
|
|
|
|
def test_append_pop(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
item_1 = paddle.static.data(
|
|
name='item_1', shape=[2, 3], dtype="float32"
|
|
)
|
|
item_2 = paddle.static.data(
|
|
name='item_2', shape=[3, 3], dtype="float32"
|
|
)
|
|
item_3 = paddle.static.data(
|
|
name='item_3', shape=[4, 3], dtype="float32"
|
|
)
|
|
|
|
item_1_np = np.random.random(size=[2, 3]).astype('float32')
|
|
item_2_np = np.random.random(size=[3, 3]).astype('float32')
|
|
item_3_np = np.random.random(size=[4, 3]).astype('float32')
|
|
|
|
array = paddle.tensor.create_array('float32')
|
|
array.append(item_1)
|
|
array.append(item_2)
|
|
array.append(item_3)
|
|
|
|
sliced_item_1 = array[0]
|
|
popped_item_3 = array.pop()
|
|
final_length = paddle.tensor.array_length(array)
|
|
(
|
|
sliced_item_1_out,
|
|
popped_item_3_out,
|
|
final_length_out,
|
|
) = exe.run(
|
|
main_program,
|
|
feed={
|
|
"item_1": item_1_np,
|
|
"item_2": item_2_np,
|
|
"item_3": item_3_np,
|
|
},
|
|
fetch_list=[sliced_item_1, popped_item_3, final_length],
|
|
)
|
|
|
|
np.testing.assert_array_equal(sliced_item_1_out, item_1_np)
|
|
np.testing.assert_array_equal(popped_item_3_out, item_3_np)
|
|
np.testing.assert_array_equal(final_length_out.item(), 2)
|
|
|
|
with self.assertRaises(TypeError):
|
|
item_1.append(array)
|
|
|
|
def test_neg(self):
|
|
x_np = np.random.uniform(-1, 1, [10, 1024]).astype(np.float32)
|
|
res = -x_np
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype="float32"
|
|
)
|
|
a = -x
|
|
b = x.__neg__()
|
|
(a_np, b_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[a, b],
|
|
)
|
|
np.testing.assert_array_equal(res, a_np)
|
|
np.testing.assert_array_equal(res, b_np)
|
|
|
|
def test_negative(self):
|
|
x_np = np.random.uniform(-1, 1, [10, 1024]).astype(np.float32)
|
|
res = -x_np
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype="float32"
|
|
)
|
|
a = -x
|
|
b = x.negative()
|
|
c = paddle.negative(x)
|
|
(a_np, b_np, c_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[a, b, c],
|
|
)
|
|
np.testing.assert_array_equal(res, a_np)
|
|
np.testing.assert_array_equal(res, b_np)
|
|
np.testing.assert_array_equal(res, c_np)
|
|
|
|
def test_abs(self):
|
|
# test for real number
|
|
x_np = np.random.uniform(-1, 1, [10, 1024]).astype(np.float32)
|
|
res = abs(x_np)
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype="float32"
|
|
)
|
|
a = abs(x)
|
|
b = x.__abs__()
|
|
(a_np, b_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[a, b],
|
|
)
|
|
np.testing.assert_array_equal(res, a_np)
|
|
np.testing.assert_array_equal(res, b_np)
|
|
|
|
def test_abs_complex(self):
|
|
# test for complex number
|
|
x_np = np.random.uniform(-1, 1, [10, 1024]).astype(
|
|
np.float32
|
|
) + 1j * np.random.uniform(-1, 1, [10, 1024]).astype(np.float32)
|
|
res = abs(x_np)
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(
|
|
name='x', shape=[10, 1024], dtype="complex64"
|
|
)
|
|
a = abs(x)
|
|
b = x.__abs__()
|
|
(a_np, b_np) = exe.run(
|
|
main_program,
|
|
feed={"x": x_np},
|
|
fetch_list=[a, b],
|
|
)
|
|
np.testing.assert_allclose(res, a_np, rtol=2e-7, atol=0.0)
|
|
np.testing.assert_allclose(res, b_np, rtol=2e-7, atol=0.0)
|
|
|
|
def test_builtin_type_conversion(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
_, _, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name='x', shape=[], dtype="float32")
|
|
with self.assertRaises(TypeError):
|
|
int(x)
|
|
with self.assertRaises(TypeError):
|
|
float(x)
|
|
with self.assertRaises(TypeError):
|
|
bool(x)
|
|
with self.assertRaises(TypeError):
|
|
complex(x)
|
|
|
|
def test_builtin_type_conversion_old_ir(self):
|
|
with paddle.pir_utils.DygraphOldIrGuard():
|
|
_, _, program_guard = new_program()
|
|
with program_guard:
|
|
x = paddle.static.data(name='x', shape=[], dtype="float32")
|
|
with self.assertRaises(TypeError):
|
|
int(x)
|
|
with self.assertRaises(TypeError):
|
|
float(x)
|
|
with self.assertRaises(TypeError):
|
|
complex(x)
|
|
|
|
def test_math_exists(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
a = paddle.static.data(name='a', shape=[1], dtype='float32')
|
|
self.assertTrue(isinstance(a, paddle.pir.Value))
|
|
self.assertTrue(inspect.ismethod(a.dot))
|
|
self.assertTrue(inspect.ismethod(a.logsumexp))
|
|
self.assertTrue(inspect.ismethod(a.multiplex))
|
|
self.assertTrue(inspect.ismethod(a.prod))
|
|
self.assertTrue(inspect.ismethod(a.scale))
|
|
self.assertTrue(inspect.ismethod(a.stanh))
|
|
self.assertTrue(inspect.ismethod(a.add_n))
|
|
self.assertTrue(inspect.ismethod(a.max))
|
|
self.assertTrue(inspect.ismethod(a.maximum))
|
|
self.assertTrue(inspect.ismethod(a.min))
|
|
self.assertTrue(inspect.ismethod(a.minimum))
|
|
self.assertTrue(inspect.ismethod(a.floor_divide))
|
|
self.assertTrue(inspect.ismethod(a.remainder))
|
|
self.assertTrue(inspect.ismethod(a.floor_mod))
|
|
self.assertTrue(inspect.ismethod(a.multiply))
|
|
self.assertTrue(inspect.ismethod(a.inverse))
|
|
self.assertTrue(inspect.ismethod(a.log1p))
|
|
self.assertTrue(inspect.ismethod(a.erf))
|
|
self.assertTrue(inspect.ismethod(a.addmm))
|
|
self.assertTrue(inspect.ismethod(a.clip))
|
|
self.assertTrue(inspect.ismethod(a.trace))
|
|
self.assertTrue(inspect.ismethod(a.kron))
|
|
self.assertTrue(inspect.ismethod(a.isinf))
|
|
self.assertTrue(inspect.ismethod(a.isnan))
|
|
self.assertTrue(inspect.ismethod(a.concat))
|
|
self.assertTrue(inspect.ismethod(a.broadcast_to))
|
|
self.assertTrue(inspect.ismethod(a.scatter_nd_add))
|
|
self.assertTrue(inspect.ismethod(a.scatter_nd))
|
|
self.assertTrue(inspect.ismethod(a.shard_index))
|
|
self.assertTrue(inspect.ismethod(a.chunk))
|
|
self.assertTrue(inspect.ismethod(a.stack))
|
|
self.assertTrue(inspect.ismethod(a.strided_slice))
|
|
self.assertTrue(inspect.ismethod(a.unsqueeze))
|
|
self.assertTrue(inspect.ismethod(a.unstack))
|
|
self.assertTrue(inspect.ismethod(a.argmax))
|
|
self.assertTrue(inspect.ismethod(a.argmin))
|
|
self.assertTrue(inspect.ismethod(a.argsort))
|
|
self.assertTrue(inspect.ismethod(a.masked_select))
|
|
self.assertTrue(inspect.ismethod(a.topk))
|
|
self.assertTrue(inspect.ismethod(a.index_select))
|
|
self.assertTrue(inspect.ismethod(a.nonzero))
|
|
self.assertTrue(inspect.ismethod(a.sort))
|
|
self.assertTrue(inspect.ismethod(a.index_sample))
|
|
self.assertTrue(inspect.ismethod(a.mean))
|
|
self.assertTrue(inspect.ismethod(a.std))
|
|
self.assertTrue(inspect.ismethod(a.numel))
|
|
self.assertTrue(inspect.ismethod(a.asin_))
|
|
self.assertTrue(inspect.ismethod(a.atan2))
|
|
self.assertTrue(inspect.ismethod(a.atanh_))
|
|
self.assertTrue(inspect.ismethod(a.diagflat))
|
|
self.assertTrue(inspect.ismethod(a.multinomial))
|
|
self.assertTrue(inspect.ismethod(a.pinv))
|
|
self.assertTrue(inspect.ismethod(a.renorm))
|
|
self.assertTrue(inspect.ismethod(a.renorm_))
|
|
self.assertTrue(inspect.ismethod(a.tan))
|
|
self.assertTrue(inspect.ismethod(a.tan_))
|
|
self.assertTrue(inspect.ismethod(a.tril))
|
|
self.assertTrue(inspect.ismethod(a.tril_))
|
|
self.assertTrue(inspect.ismethod(a.triu))
|
|
self.assertTrue(inspect.ismethod(a.triu_))
|
|
self.assertTrue(inspect.ismethod(a.stft))
|
|
self.assertTrue(inspect.ismethod(a.istft))
|
|
self.assertTrue(inspect.ismethod(a.abs_))
|
|
self.assertTrue(inspect.ismethod(a.acos_))
|
|
self.assertTrue(inspect.ismethod(a.atan_))
|
|
self.assertTrue(inspect.ismethod(a.cos_))
|
|
self.assertTrue(inspect.ismethod(a.cosh_))
|
|
self.assertTrue(inspect.ismethod(a.sin_))
|
|
self.assertTrue(inspect.ismethod(a.sinh_))
|
|
self.assertTrue(inspect.ismethod(a.acosh_))
|
|
self.assertTrue(inspect.ismethod(a.asinh_))
|
|
self.assertTrue(inspect.ismethod(a.diag))
|
|
|
|
def test_binary_op_with_scalar(self):
|
|
with paddle.pir_utils.IrGuard():
|
|
main_program, exe, program_guard = new_program()
|
|
with program_guard:
|
|
x_np = np.array(10, dtype=np.int32)
|
|
x = paddle.static.data(name='x', shape=[], dtype="int32")
|
|
y1 = x / 2
|
|
y2 = x / 5.0
|
|
y3 = x // 2
|
|
y4 = x * 8.0
|
|
self.assertEqual(y1.dtype, paddle.pir.core.DataType.FLOAT32)
|
|
self.assertEqual(y2.dtype, paddle.pir.core.DataType.FLOAT32)
|
|
self.assertEqual(y3.dtype, paddle.pir.core.DataType.INT32)
|
|
self.assertEqual(y4.dtype, paddle.pir.core.DataType.FLOAT32)
|
|
(y1_out, y2_out, y3_out, y4_out) = exe.run(
|
|
main_program,
|
|
feed={
|
|
"x": x_np,
|
|
},
|
|
fetch_list=[y1, y2, y3, y4],
|
|
)
|
|
np.testing.assert_allclose(x_np / 2, y1_out, rtol=1e-05)
|
|
np.testing.assert_allclose(x_np / 5.0, y2_out, rtol=1e-05)
|
|
np.testing.assert_allclose(x_np // 2, y3_out, atol=1e-05)
|
|
np.testing.assert_allclose(x_np * 8.0, y4_out, rtol=1e-05)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|