m53297601
/
Paddle
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

delete axis parameter in multiply api (#28647)

Browse Source 
As the title
musl/disable_test_yolov3_temporarily
joejiong 4 years ago committed by GitHub
parent c098a2e159
commit 4b05a8be88
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 79 additions and 140 deletions
Show Stats Download Patch File Download Diff File

10
python/paddle/fluid/tests/unittests/rnn/test_rnn_nets.py
Unescape View File

@ -88,7 +88,8 @@ class TestSimpleRNN(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len) y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len)
y2 = paddle.multiply(y2, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y2 = paddle.multiply(y2, mask)
np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5)
np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5)
@ -174,7 +175,8 @@ class TestGRU(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len) y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len)
y2 = paddle.multiply(y2, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y2 = paddle.multiply(y2, mask)
np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5)
np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5)
@ -259,7 +261,8 @@ class TestLSTM(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y2, (h2, c2) = rnn2(paddle.to_tensor(x), sequence_length=seq_len) y2, (h2, c2) = rnn2(paddle.to_tensor(x), sequence_length=seq_len)
y2 = paddle.multiply(y2, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y2 = paddle.multiply(y2, mask)
np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5)
np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5)
@ -343,5 +346,6 @@ def load_tests(loader, tests, pattern):
suite.addTest(test_class(time_major, direction, device)) suite.addTest(test_class(time_major, direction, device))
return suite return suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

9
python/paddle/fluid/tests/unittests/rnn/test_rnn_nets_static.py
Unescape View File

@ -151,7 +151,8 @@ class TestSimpleRNN(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y, h = rnn2(x_data, sequence_length=seq_len) y, h = rnn2(x_data, sequence_length=seq_len)
y = paddle.multiply(y, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y = paddle.multiply(y, mask)
feed_dict = {x_data.name: x, seq_len.name: sequence_length} feed_dict = {x_data.name: x, seq_len.name: sequence_length}
@ -297,7 +298,8 @@ class TestGRU(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y, h = rnn2(x_data, sequence_length=seq_len) y, h = rnn2(x_data, sequence_length=seq_len)
y = paddle.multiply(y, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y = paddle.multiply(y, mask)
feed_dict = {x_data.name: x, seq_len.name: sequence_length} feed_dict = {x_data.name: x, seq_len.name: sequence_length}
@ -445,7 +447,8 @@ class TestLSTM(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y, (h, c) = rnn2(x_data, sequence_length=seq_len) y, (h, c) = rnn2(x_data, sequence_length=seq_len)
y = paddle.multiply(y, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y = paddle.multiply(y, mask)
feed_dict = {x_data.name: x, seq_len.name: sequence_length} feed_dict = {x_data.name: x, seq_len.name: sequence_length}

6
python/paddle/fluid/tests/unittests/rnn/test_wrappers.py
Unescape View File

@ -89,7 +89,8 @@ class TestRNNWrapper(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len) y2, h2 = rnn2(paddle.to_tensor(x), sequence_length=seq_len)
y2 = paddle.multiply(y2, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y2 = paddle.multiply(y2, mask)
np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5)
np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(h1, h2.numpy(), atol=1e-8, rtol=1e-5)
@ -169,7 +170,8 @@ class TestBiRNNWrapper(unittest.TestCase):
if self.time_major: if self.time_major:
mask = paddle.transpose(mask, [1, 0]) mask = paddle.transpose(mask, [1, 0])
y2, (fw_h2, bw_h2) = rnn2(paddle.to_tensor(x), sequence_length=seq_len) y2, (fw_h2, bw_h2) = rnn2(paddle.to_tensor(x), sequence_length=seq_len)
y2 = paddle.multiply(y2, mask, axis=0) mask = paddle.unsqueeze(mask, -1)
y2 = paddle.multiply(y2, mask)
np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(y1, y2.numpy(), atol=1e-8, rtol=1e-5)
np.testing.assert_allclose(fw_h1, fw_h2.numpy(), atol=1e-8, rtol=1e-5) np.testing.assert_allclose(fw_h1, fw_h2.numpy(), atol=1e-8, rtol=1e-5)

161
python/paddle/fluid/tests/unittests/test_multiply.py
Unescape View File

@ -13,176 +13,84 @@
# limitations under the License. # limitations under the License.
from __future__ import print_function from __future__ import print_function
import paddle
import paddle.tensor as tensor
import paddle.fluid as fluid
from paddle.fluid import Program, program_guard
import numpy as np
import unittest import unittest
import numpy as np
import paddle
import paddle.tensor as tensor
from paddle.static import Program, program_guard
class TestMultiplyAPI(unittest.TestCase):
"""TestMultiplyAPI."""
def __run_static_graph_case(self, x_data, y_data, axis=-1): class TestMultiplyApi(unittest.TestCase):
def _run_static_graph_case(self, x_data, y_data):
with program_guard(Program(), Program()): with program_guard(Program(), Program()):
paddle.enable_static() paddle.enable_static()
x = paddle.static.data( x = paddle.static.data(
name='x', shape=x_data.shape, dtype=x_data.dtype) name='x', shape=x_data.shape, dtype=x_data.dtype)
y = paddle.static.data( y = paddle.static.data(
name='y', shape=y_data.shape, dtype=y_data.dtype) name='y', shape=y_data.shape, dtype=y_data.dtype)
res = tensor.multiply(x, y, axis=axis) res = tensor.multiply(x, y)
place = fluid.CUDAPlace(0) if fluid.core.is_compiled_with_cuda(
) else fluid.CPUPlace()
exe = fluid.Executor(place)
outs = exe.run(fluid.default_main_program(),
feed={'x': x_data,
'y': y_data},
fetch_list=[res])
res = outs[0]
return res
def __run_static_graph_case_with_numpy_input(self, x_data, y_data, axis=-1):
with program_guard(Program(), Program()):
paddle.enable_static()
res = tensor.multiply(x_data, y_data, axis=axis) place = paddle.CUDAPlace(0) if paddle.is_compiled_with_cuda(
place = fluid.CUDAPlace(0) if fluid.core.is_compiled_with_cuda( ) else paddle.CPUPlace()
) else fluid.CPUPlace() exe = paddle.static.Executor(place)
exe = fluid.Executor(place) outs = exe.run(paddle.static.default_main_program(),
outs = exe.run(fluid.default_main_program(),
feed={'x': x_data, feed={'x': x_data,
'y': y_data}, 'y': y_data},
fetch_list=[res]) fetch_list=[res])
res = outs[0] res = outs[0]
return res return res
def __run_dynamic_graph_case(self, x_data, y_data, axis=-1): def _run_dynamic_graph_case(self, x_data, y_data):
paddle.disable_static() paddle.disable_static()
x = paddle.to_tensor(x_data) x = paddle.to_tensor(x_data)
y = paddle.to_tensor(y_data) y = paddle.to_tensor(y_data)
res = paddle.multiply(x, y, axis=axis) res = paddle.multiply(x, y)
return res.numpy()
def __run_dynamic_graph_case_with_numpy_input(self, x_data, y_data,
axis=-1):
paddle.disable_static()
res = paddle.multiply(x_data, y_data, axis=axis)
return res.numpy() return res.numpy()
def test_multiply(self): def test_multiply(self):
"""test_multiply."""
np.random.seed(7) np.random.seed(7)
# test static computation graph: 1-d array # test static computation graph: 1-d array
x_data = np.random.rand(200) x_data = np.random.rand(200)
y_data = np.random.rand(200) y_data = np.random.rand(200)
res = self.__run_static_graph_case(x_data, y_data) res = self._run_static_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph: 1-d array
x_data = np.random.rand(200)
y_data = np.random.rand(200)
res = self.__run_static_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph: 2-d array # test static computation graph: 2-d array
x_data = np.random.rand(2, 500) x_data = np.random.rand(2, 500)
y_data = np.random.rand(2, 500) y_data = np.random.rand(2, 500)
res = self.__run_static_graph_case(x_data, y_data) res = self._run_static_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph with_primitives: 2-d array
x_data = np.random.rand(2, 500)
y_data = np.random.rand(2, 500)
res = self.__run_static_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph: broadcast # test static computation graph: broadcast
x_data = np.random.rand(2, 500) x_data = np.random.rand(2, 500)
y_data = np.random.rand(500) y_data = np.random.rand(500)
res = self.__run_static_graph_case(x_data, y_data) res = self._run_static_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph with_primitives: broadcast
x_data = np.random.rand(2, 500)
y_data = np.random.rand(500)
res = self.__run_static_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test static computation graph: broadcast with axis
x_data = np.random.rand(2, 300, 40)
y_data = np.random.rand(300)
res = self.__run_static_graph_case(x_data, y_data, axis=1)
expected = np.multiply(x_data, y_data[..., np.newaxis])
self.assertTrue(np.allclose(res, expected))
# test static computation graph with_primitives: broadcast with axis
x_data = np.random.rand(2, 300, 40)
y_data = np.random.rand(300)
res = self.__run_static_graph_case_with_numpy_input(
x_data, y_data, axis=1)
expected = np.multiply(x_data, y_data[..., np.newaxis])
self.assertTrue(np.allclose(res, expected))
# test dynamic computation graph: 1-d array # test dynamic computation graph: 1-d array
x_data = np.random.rand(200) x_data = np.random.rand(200)
y_data = np.random.rand(200) y_data = np.random.rand(200)
res = self.__run_dynamic_graph_case(x_data, y_data) res = self._run_dynamic_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic numpy input computation graph: 1-d array
x_data = np.random.rand(200)
y_data = np.random.rand(200)
res = self.__run_dynamic_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic computation graph: 2-d array # test dynamic computation graph: 2-d array
x_data = np.random.rand(20, 50) x_data = np.random.rand(20, 50)
y_data = np.random.rand(20, 50) y_data = np.random.rand(20, 50)
res = self.__run_dynamic_graph_case(x_data, y_data) res = self._run_dynamic_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic numpy input computation graph: 1-d array
x_data = np.random.rand(20, 50)
y_data = np.random.rand(20, 50)
res = self.__run_dynamic_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic computation graph: broadcast # test dynamic computation graph: broadcast
x_data = np.random.rand(2, 500) x_data = np.random.rand(2, 500)
y_data = np.random.rand(500) y_data = np.random.rand(500)
res = self.__run_dynamic_graph_case(x_data, y_data) res = self._run_dynamic_graph_case(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data))) self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic computation graph with numpy tensor: broadcast
x_data = np.random.rand(2, 500)
y_data = np.random.rand(500)
res = self.__run_dynamic_graph_case_with_numpy_input(x_data, y_data)
self.assertTrue(np.allclose(res, np.multiply(x_data, y_data)))
# test dynamic computation graph: broadcast with axis
x_data = np.random.rand(2, 300, 40)
y_data = np.random.rand(300)
res = self.__run_dynamic_graph_case(x_data, y_data, axis=1)
expected = np.multiply(x_data, y_data[..., np.newaxis])
self.assertTrue(np.allclose(res, expected))
# test dynamic computation graph with numpy tensor: broadcast with axis
x_data = np.random.rand(2, 300, 40)
y_data = np.random.rand(300)
res = self.__run_dynamic_graph_case_with_numpy_input(
x_data, y_data, axis=1)
expected = np.multiply(x_data, y_data[..., np.newaxis])
self.assertTrue(np.allclose(res, expected))
class TestMultiplyError(unittest.TestCase): class TestMultiplyError(unittest.TestCase):
"""TestMultiplyError."""
def test_errors(self): def test_errors(self):
"""test_errors."""
# test static computation graph: dtype can not be int8 # test static computation graph: dtype can not be int8
paddle.enable_static() paddle.enable_static()
with program_guard(Program(), Program()): with program_guard(Program(), Program()):
@ -226,6 +134,35 @@ class TestMultiplyError(unittest.TestCase):
y = paddle.to_tensor(y_data) y = paddle.to_tensor(y_data)
self.assertRaises(TypeError, paddle.multiply, x, y) self.assertRaises(TypeError, paddle.multiply, x, y)
# test dynamic computation graph: dtype must be Tensor type
x_data = np.random.randn(200).astype(np.int64)
y_data = np.random.randn(200).astype(np.float64)
y = paddle.to_tensor(y_data)
self.assertRaises(TypeError, paddle.multiply, x_data, y)
# test dynamic computation graph: dtype must be Tensor type
x_data = np.random.randn(200).astype(np.int64)
y_data = np.random.randn(200).astype(np.float64)
x = paddle.to_tensor(x_data)
self.assertRaises(TypeError, paddle.multiply, x, y_data)
# test dynamic computation graph: dtype must be Tensor type
x_data = np.random.randn(200).astype(np.float32)
y_data = np.random.randn(200).astype(np.float32)
x = paddle.to_tensor(x_data)
self.assertRaises(TypeError, paddle.multiply, x, y_data)
# test dynamic computation graph: dtype must be Tensor type
x_data = np.random.randn(200).astype(np.float32)
y_data = np.random.randn(200).astype(np.float32)
x = paddle.to_tensor(x_data)
self.assertRaises(TypeError, paddle.multiply, x_data, y)
# test dynamic computation graph: dtype must be Tensor type
x_data = np.random.randn(200).astype(np.float32)
y_data = np.random.randn(200).astype(np.float32)
self.assertRaises(TypeError, paddle.multiply, x_data, y_data)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

2
python/paddle/nn/functional/loss.py
Unescape View File

@ -166,7 +166,7 @@ def binary_cross_entropy(input, label, weight=None, reduction='mean',
if weight is not None: if weight is not None:
if isinstance(weight, paddle.static.Variable): if isinstance(weight, paddle.static.Variable):
weight_name = name if reduction is 'none' else None weight_name = name if reduction is 'none' else None
out = paddle.multiply(out, weight, axis=-1, name=weight_name) out = paddle.multiply(out, weight, name=weight_name)
else: else:
raise ValueError( raise ValueError(
"The weight is not a Tensor, please convert to Tensor.") "The weight is not a Tensor, please convert to Tensor.")

4
python/paddle/nn/utils/weight_norm_hook.py
Unescape View File

@ -18,7 +18,6 @@ from ...fluid import dygraph
from ...fluid import layers as F from ...fluid import layers as F
from ...fluid.layer_helper import LayerHelper from ...fluid.layer_helper import LayerHelper
from ...fluid.data_feeder import check_variable_and_dtype from ...fluid.data_feeder import check_variable_and_dtype
from ...tensor.math import multiply
__all__ = ['weight_norm', 'remove_weight_norm'] __all__ = ['weight_norm', 'remove_weight_norm']
@ -86,7 +85,8 @@ def _weight_norm(v, g, dim):
v_normalized = F.l2_normalize(p_matrix, axis=1) v_normalized = F.l2_normalize(p_matrix, axis=1)
v_normalized = F.reshape(v_normalized, transposed_shape) v_normalized = F.reshape(v_normalized, transposed_shape)
v_normalized = F.transpose(v_normalized, perm) v_normalized = F.transpose(v_normalized, perm)
weight = multiply(v_normalized, g, axis=dim if dim is not None else -1) weight = F.elementwise_mul(
v_normalized, g, axis=dim if dim is not None else -1)
return weight return weight

27
python/paddle/tensor/math.py
Unescape View File

@ -421,7 +421,7 @@ mod = remainder #DEFINE_ALIAS
floor_mod = remainder #DEFINE_ALIAS floor_mod = remainder #DEFINE_ALIAS
def multiply(x, y, axis=-1, name=None): def multiply(x, y, name=None):
""" """
multiply two tensors element-wise. The equation is: multiply two tensors element-wise. The equation is:
@ -445,20 +445,20 @@ def multiply(x, y, axis=-1, name=None):
import paddle import paddle
paddle.disable_static()
x = paddle.to_tensor([[1, 2], [3, 4]]) x = paddle.to_tensor([[1, 2], [3, 4]])
y = paddle.to_tensor([[5, 6], [7, 8]]) y = paddle.to_tensor([[5, 6], [7, 8]])
res = paddle.multiply(x, y) res = paddle.multiply(x, y)
print(res.numpy()) # [[5, 12], [21, 32]] print(res) # [[5, 12], [21, 32]]
x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]]) x = paddle.to_tensor([[[1, 2, 3], [1, 2, 3]]])
y = paddle.to_tensor([1, 2]) y = paddle.to_tensor([2])
res = paddle.multiply(x, y, axis=1) res = paddle.multiply(x, y)
print(res.numpy()) # [[[1, 2, 3], [2, 4, 6]]] print(res) # [[[2, 4, 6], [2, 4, 6]]]
""" """
op_type = 'elementwise_mul' op_type = 'elementwise_mul'
act = None act = None
axis = -1
if x.dtype != y.dtype: if x.dtype != y.dtype:
raise TypeError( raise TypeError(
@ -467,19 +467,12 @@ def multiply(x, y, axis=-1, name=None):
if in_dygraph_mode(): if in_dygraph_mode():
if not isinstance(x, (paddle.Tensor)): if not isinstance(x, (paddle.Tensor)):
x = paddle.to_tensor(x) raise TypeError(
if not isinstance(y, (paddle.Tensor)): 'Input x must tensor type, but received type of x: %s'
y = paddle.to_tensor(y) % (x.dtype))
return _elementwise_op_in_dygraph( return _elementwise_op_in_dygraph(
x, y, axis=axis, act=act, op_name=op_type) x, y, axis=axis, act=act, op_name=op_type)
if not isinstance(x, (paddle.Tensor, Variable)):
x = paddle.static.data(
name='x', shape=x.shape, dtype=x.dtype)
if not isinstance(y, (paddle.Tensor, Variable)):
y = paddle.static.data(
name='y', shape=y.shape, dtype=y.dtype)
return _elementwise_op(LayerHelper(op_type, **locals())) return _elementwise_op(LayerHelper(op_type, **locals()))
def maximum(x, y, axis=-1, name=None): def maximum(x, y, axis=-1, name=None):

Write Preview
Loading…
Cancel
Save