# Copyright (c) 2018 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. from __future__ import print_function import unittest import numpy as np import paddle import paddle.fluid.core as core from op_test import OpTest import paddle.fluid as fluid from paddle.fluid import Program, program_guard class TestAddMMOp(OpTest): # test basic def setUp(self): self.op_type = "addmm" self.python_api = paddle.addmm self.dtype = np.float64 self.init_dtype_type() self.inputs = { 'Input': np.random.random((100, 1)).astype(self.dtype), 'X': np.random.random((100, 10)).astype(self.dtype), 'Y': np.random.random((10, 20)).astype(self.dtype), } self.outputs = { 'Out': self.inputs['Input'] + np.dot(self.inputs['X'], self.inputs['Y']) } def init_dtype_type(self): pass def test_check_output(self): self.check_output(check_eager=False) def test_check_grad_normal(self): self.check_grad(['Input', 'X', 'Y'], 'Out', check_eager=False) def test_check_grad_x(self): self.check_grad(['X'], 'Out', no_grad_set=None, check_eager=False) def test_check_grad_y(self): self.check_grad(['Y'], 'Out', no_grad_set=None, check_eager=False) def test_check_grad_input(self): self.check_grad(['Input'], 'Out', no_grad_set=None, check_eager=False) class TestAddMMOpError(unittest.TestCase): # test error def test_errors(self): with program_guard(Program(), Program()): # The input type of addmm_op must be Variable. input = fluid.create_lod_tensor( np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) x1 = fluid.create_lod_tensor( np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) x2 = fluid.create_lod_tensor( np.array([[-1, -1], [-1, -1]]), [[2]], fluid.CPUPlace()) self.assertRaises(TypeError, paddle.addmm, input, x1, x2) # The input dtype of mul_op must be float32 or float64. input = fluid.layers.data( name='input', shape=[4, 4], dtype="int32", append_batch_size=False) x3 = fluid.layers.data( name='x3', shape=[4, 4], dtype="int32", append_batch_size=False) x4 = fluid.layers.data( name='x4', shape=[4, 4], dtype="int32", append_batch_size=False) self.assertRaises(TypeError, paddle.addmm, input, x3, x4) # x and y dimension mismatch x5 = fluid.layers.data( name='x5', shape=[4, 5], dtype="float32", append_batch_size=False) x6 = fluid.layers.data( name='x6', shape=[4, 4], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input, x5, x6) # input and x are not broadcastable x7 = fluid.layers.data( name='x7', shape=[4, 4], dtype="float32", append_batch_size=False) x8 = fluid.layers.data( name='x8', shape=[4, 4], dtype="float32", append_batch_size=False) input1 = fluid.layers.data( name='input1', shape=[2, 4], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input1, x7, x8) # input and x are not broadcastable x9 = fluid.layers.data( name='x9', shape=[4, 4], dtype="float32", append_batch_size=False) x10 = fluid.layers.data( name='x10', shape=[4, 4], dtype="float32", append_batch_size=False) input2 = fluid.layers.data( name='input2', shape=[1, 2], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input2, x9, x10) x11 = fluid.layers.data( name='x11', shape=[4, 4], dtype="float32", append_batch_size=False) x12 = fluid.layers.data( name='x12', shape=[4, 4], dtype="float32", append_batch_size=False) input3 = fluid.layers.data( name='input3', shape=[4, 2], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input3, x11, x12) x13 = fluid.layers.data( name='x13', shape=[4, 4], dtype="float32", append_batch_size=False) x14 = fluid.layers.data( name='x14', shape=[4, 4], dtype="float32", append_batch_size=False) input4 = fluid.layers.data( name='input4', shape=[3, 1], dtype="float32", append_batch_size=False) self.assertRaises(ValueError, paddle.addmm, input4, x13, x14) class TestAddMMOp2(TestAddMMOp): # test alpha and beta def setUp(self): self.op_type = "addmm" self.python_api = paddle.addmm self.dtype = np.float64 self.init_dtype_type() self.inputs = { 'Input': np.random.random((20, 30)).astype(self.dtype), 'X': np.random.random((20, 6)).astype(self.dtype), 'Y': np.random.random((6, 30)).astype(self.dtype), } self.attrs = { 'Alpha': 0.1, 'Beta': 1.0, } self.outputs = {'Out': self.attrs['Beta'] * self.inputs['Input'] + \ self.attrs['Alpha'] * np.dot(self.inputs['X'], self.inputs['Y'])} class TestAddMMOp3(OpTest): # test broadcast def setUp(self): self.op_type = "addmm" self.dtype = np.float64 self.init_dtype_type() self.inputs = { 'Input': np.random.random((1, 100)).astype(self.dtype), 'X': np.random.random((20, 10)).astype(self.dtype), 'Y': np.random.random((10, 100)).astype(self.dtype), } self.attrs = { 'Alpha': 0.5, 'Beta': 2.0, } self.outputs = {'Out': self.attrs['Beta'] * self.inputs['Input'] + \ self.attrs['Alpha'] * np.dot(self.inputs['X'], self.inputs['Y'])} def init_dtype_type(self): pass def test_check_output(self): self.check_output() def test_check_grad_normal(self): self.check_grad(['Input', 'X', 'Y'], 'Out') def test_check_grad_x(self): self.check_grad(['X'], 'Out', no_grad_set=None) def test_check_grad_y(self): self.check_grad(['Y'], 'Out', no_grad_set=None) def test_check_grad_input(self): self.check_grad(['Input'], 'Out', no_grad_set=None) class TestAddMMOp4(OpTest): # test broadcast def setUp(self): self.op_type = "addmm" self.dtype = np.float64 self.init_dtype_type() self.inputs = { 'Input': np.random.random((100)).astype(self.dtype), 'X': np.random.random((20, 10)).astype(self.dtype), 'Y': np.random.random((10, 100)).astype(self.dtype), } self.attrs = { 'Alpha': 0.5, 'Beta': 2.0, } self.outputs = {'Out': self.attrs['Beta'] * self.inputs['Input'] + \ self.attrs['Alpha'] * np.dot(self.inputs['X'], self.inputs['Y'])} def init_dtype_type(self): pass def test_check_output(self): self.check_output() def test_check_grad_normal(self): self.check_grad(['Input', 'X', 'Y'], 'Out') def test_check_grad_x(self): self.check_grad(['X'], 'Out', no_grad_set=None) def test_check_grad_y(self): self.check_grad(['Y'], 'Out', no_grad_set=None) def test_check_grad_input(self): self.check_grad(['Input'], 'Out', no_grad_set=None) class TestAddMMOp5(unittest.TestCase): def test_api_with_dygraph(self): np_input = np.random.random((20, 30)).astype(np.float32) np_x = np.random.random((20, 6)).astype(np.float32) np_y = np.random.random((6, 30)).astype(np.float32) with fluid.dygraph.guard(): input = fluid.dygraph.to_variable(np_input) x = fluid.dygraph.to_variable(np_x) y = fluid.dygraph.to_variable(np_y) out = paddle.tensor.addmm(input, x, y) assert np.allclose(np_input + np.dot(np_x, np_y), out.numpy()) class TestAddMMAPI(unittest.TestCase): def test_api_error(self): data_x = np.ones((2, 2)).astype(np.float32) data_y = np.ones((2, 2)).astype(np.float32) data_input = np.ones((2, 2)).astype(np.float32) paddle.disable_static() def test_error1(): data_x_wrong = np.ones((2, 3)).astype(np.float32) x = paddle.to_tensor(data_x_wrong) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input) out = paddle.tensor.addmm( input=input, x=x, y=y, beta=0.5, alpha=5.0) self.assertRaises(ValueError, test_error1) def test_error2(): data_x_wrong = np.ones((2)).astype(np.float32) x = paddle.to_tensor(data_x_wrong) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input) out = paddle.tensor.addmm( input=input, x=x, y=y, beta=0.5, alpha=5.0) self.assertRaises(ValueError, test_error2) def test_error3(): data_input_wrong = np.ones((2, 2, 2)).astype(np.float32) x = paddle.to_tensor(data_x) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input_wrong) out = paddle.tensor.addmm( input=input, x=x, y=y, beta=0.5, alpha=5.0) self.assertRaises(ValueError, test_error3) def test_error4(): data_input_wrong = np.ones((5)).astype(np.float32) x = paddle.to_tensor(data_x) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input_wrong) out = paddle.tensor.addmm( input=input, x=x, y=y, beta=0.5, alpha=5.0) self.assertRaises(ValueError, test_error4) paddle.enable_static() def test_api_normal_1(self): data_x = np.ones((2, 2)).astype(np.float32) data_y = np.ones((2, 2)).astype(np.float32) data_input = np.ones((2, 2)).astype(np.float32) data_alpha = 0.1 data_beta = 1.0 paddle.disable_static() x = paddle.to_tensor(data_x) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input) paddle_output = paddle.tensor.addmm( input=input, x=x, y=y, beta=data_beta, alpha=data_alpha) numpy_output = data_beta * data_input + data_alpha * np.dot(data_x, data_y) self.assertEqual(np.allclose(numpy_output, paddle_output.numpy()), True) paddle.enable_static() def test_api_normal_2(self): data_x = np.ones((3, 10)).astype(np.float32) data_y = np.ones((10, 3)).astype(np.float32) data_input = np.ones((3)).astype(np.float32) data_alpha = 0.1 data_beta = 1.0 paddle.disable_static() x = paddle.to_tensor(data_x) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input) paddle_output = paddle.tensor.addmm( input=input, x=x, y=y, beta=data_beta, alpha=data_alpha) numpy_output = data_beta * data_input + data_alpha * np.dot(data_x, data_y) self.assertEqual(np.allclose(numpy_output, paddle_output.numpy()), True) paddle.enable_static() def test_api_normal_3(self): data_x = np.ones((3, 10)).astype(np.float32) data_y = np.ones((10, 3)).astype(np.float32) data_input = np.ones((1)).astype(np.float32) data_alpha = 0.1 data_beta = 1.0 paddle.disable_static() x = paddle.to_tensor(data_x) y = paddle.to_tensor(data_y) input = paddle.to_tensor(data_input) paddle_output = paddle.tensor.addmm( input=input, x=x, y=y, beta=data_beta, alpha=data_alpha) numpy_output = data_beta * data_input + data_alpha * np.dot(data_x, data_y) self.assertEqual(np.allclose(numpy_output, paddle_output.numpy()), True) paddle.enable_static() if __name__ == "__main__": paddle.enable_static() unittest.main()