Skip to content

P
Paddle

PaddlePaddle / Paddle
大约 1 年 前同步成功

通知 2299
Star 20931
Fork 5422
P
Paddle
未验证 提交 c6c9c186 编写于 作者: N Nyakku Shigure 提交者： GitHub
浏览文件
操作

[CodeStyle] remove crlf for python files (#46155)

上级 9941ec12
展开全部 隐藏空白更改
内联 并排
Showing with 1497 addition and 1497 deletion
python/paddle/fluid/tests/unittests/asp/test_asp_utils.py
浏览文件 @ c6c9c186
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
# Copyright (c) 2021 NVIDIA Corporation. All rights reserved. # Copyright (c) 2021 NVIDIA Corporation. All rights reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from __future__ import print_function from __future__ import print_function
import unittest import unittest
import threading, time import threading, time
import paddle import paddle
import numpy as np import numpy as np
class TestASPUtils(unittest.TestCase): class TestASPUtils(unittest.TestCase):
def test_get_check_method(self): def test_get_check_method(self):
self.assertEqual( self.assertEqual(
paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method( paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method(
paddle.fluid.contrib.sparsity.MaskAlgo.MASK_1D), paddle.fluid.contrib.sparsity.MaskAlgo.MASK_1D),
paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D) paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D)
self.assertEqual( self.assertEqual(
paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method( paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method(
paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_GREEDY), paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_GREEDY),
paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D) paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D)
self.assertEqual( self.assertEqual(
paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method( paddle.fluid.contrib.sparsity.CheckMethod.get_checking_method(
paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_BEST), paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_BEST),
paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D) paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D)
def test_density(self): def test_density(self):
x = np.array([[1.0, 1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], x = np.array([[1.0, 1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0],
[1.0, 0.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0],
[0.0, 1.0, 0.0, 0.0, 1.0]]) [0.0, 1.0, 0.0, 0.0, 1.0]])
self.assertEqual(paddle.incubate.asp.calculate_density(x), 0.56) self.assertEqual(paddle.incubate.asp.calculate_density(x), 0.56)
x[:, 0] = 0.0 x[:, 0] = 0.0
self.assertEqual(paddle.incubate.asp.calculate_density(x), 0.4) self.assertEqual(paddle.incubate.asp.calculate_density(x), 0.4)
def test_check_mask_1d(self): def test_check_mask_1d(self):
x = np.array([[1.0, 0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], x = np.array([[1.0, 0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0],
[1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0],
[0.0, 1.0, 0.0, 0.0, 1.0]]) [0.0, 1.0, 0.0, 0.0, 1.0]])
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 2, 4)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 2, 4))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 4)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 4))
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 2, 5)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 2, 5))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 5)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 5))
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 6)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(x, 3, 6))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 4, 6)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_1d(x, 4, 6))
def test_get_mask_1d(self): def test_get_mask_1d(self):
for _ in range(10): for _ in range(10):
x = np.random.randint(10, size=(5, 5)) x = np.random.randint(10, size=(5, 5))
x = paddle.fluid.contrib.sparsity.get_mask_1d(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_1d(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(
x, 2, 4)) x, 2, 4))
x = np.random.randn(5, 4) x = np.random.randn(5, 4)
x = paddle.fluid.contrib.sparsity.get_mask_1d(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_1d(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_1d(
x, 2, 4)) x, 2, 4))
def test_check_mask_2d(self): def test_check_mask_2d(self):
x = np.array([[1.0, 0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0, 0.0], x = np.array([[1.0, 0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 0.0],
[0.0, 1.0, 0.0, 0.0, 1.0]]) [0.0, 1.0, 0.0, 0.0, 1.0]])
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 2, 4)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 2, 4))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 4)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 4))
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 2, 5)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 2, 5))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 5)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 5))
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 6)) self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(x, 3, 6))
self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 4, 6)) self.assertFalse(paddle.fluid.contrib.sparsity.check_mask_2d(x, 4, 6))
def test_get_mask_2d_greedy(self): def test_get_mask_2d_greedy(self):
for _ in range(10): for _ in range(10):
x = np.random.randint(10, size=(5, 5)) x = np.random.randint(10, size=(5, 5))
x = paddle.fluid.contrib.sparsity.get_mask_2d_greedy(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_2d_greedy(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(
x, 2, 4)) x, 2, 4))
x = np.random.randn(5, 4) x = np.random.randn(5, 4)
x = paddle.fluid.contrib.sparsity.get_mask_2d_greedy(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_2d_greedy(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(
x, 2, 4)) x, 2, 4))
def test_get_mask_2d_best(self): def test_get_mask_2d_best(self):
for _ in range(10): for _ in range(10):
x = np.random.randint(10, size=(5, 5)) x = np.random.randint(10, size=(5, 5))
x = paddle.fluid.contrib.sparsity.get_mask_2d_best(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_2d_best(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(
x, 2, 4)) x, 2, 4))
x = np.random.randn(5, 4) x = np.random.randn(5, 4)
x = paddle.fluid.contrib.sparsity.get_mask_2d_best(x, 2, 4) x = paddle.fluid.contrib.sparsity.get_mask_2d_best(x, 2, 4)
self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d( self.assertTrue(paddle.fluid.contrib.sparsity.check_mask_2d(
x, 2, 4)) x, 2, 4))
def test_threadsafe_valid_2d_patterns(self): def test_threadsafe_valid_2d_patterns(self):
def get_reference(m=4, n=2): def get_reference(m=4, n=2):
from itertools import permutations from itertools import permutations
patterns = np.zeros(m) patterns = np.zeros(m)
patterns[:n] = 1 patterns[:n] = 1
patterns = list(set(permutations(patterns.tolist()))) patterns = list(set(permutations(patterns.tolist())))
patterns = patterns + patterns patterns = patterns + patterns
patterns = np.asarray(list(set(permutations(patterns, m)))) patterns = np.asarray(list(set(permutations(patterns, m))))
valid = ((patterns.sum(axis=1) <= n).sum( valid = ((patterns.sum(axis=1) <= n).sum(
axis=1) == m).nonzero()[0].reshape(-1) axis=1) == m).nonzero()[0].reshape(-1)
valid_patterns = np.empty((valid.shape[0], m, m)) valid_patterns = np.empty((valid.shape[0], m, m))
valid_patterns[:] = patterns[valid[:]] valid_patterns[:] = patterns[valid[:]]
return valid_patterns return valid_patterns
for _ in range(4): for _ in range(4):
computing_thread = threading.Thread( computing_thread = threading.Thread(
target=paddle.fluid.contrib.sparsity.utils. target=paddle.fluid.contrib.sparsity.utils.
_compute_valid_2d_patterns, _compute_valid_2d_patterns,
args=(2, 4)) args=(2, 4))
computing_thread.start() computing_thread.start()
time.sleep(3) time.sleep(3)
patterns_map = paddle.fluid.contrib.sparsity.utils._valid_2d_patterns patterns_map = paddle.fluid.contrib.sparsity.utils._valid_2d_patterns
reference_patterns = get_reference() reference_patterns = get_reference()
reference_key = '4_2' reference_key = '4_2'
self.assertTrue(reference_key in patterns_map) self.assertTrue(reference_key in patterns_map)
self.assertTrue(len(patterns_map) == 1) self.assertTrue(len(patterns_map) == 1)
self.assertTrue( self.assertTrue(
(reference_patterns == patterns_map[reference_key]).all()) (reference_patterns == patterns_map[reference_key]).all())
def test_check_sparsity(self): def test_check_sparsity(self):
for _ in range(10): for _ in range(10):
x = np.random.randint(10, size=(5)) x = np.random.randint(10, size=(5))
x_2d = x.reshape(1, x.shape[0]) x_2d = x.reshape(1, x.shape[0])
self.__test_1D_2D_sparsity_checking_methods(x_2d) self.__test_1D_2D_sparsity_checking_methods(x_2d)
x = np.random.randint(10, size=(5, 5)) x = np.random.randint(10, size=(5, 5))
x_2d = x x_2d = x
self.__test_1D_2D_sparsity_checking_methods(x_2d) self.__test_1D_2D_sparsity_checking_methods(x_2d)
x = np.random.randint(10, size=(5, 5, 5)) x = np.random.randint(10, size=(5, 5, 5))
x_2d = x.reshape(x.shape[0] * x.shape[1], x.shape[2]) x_2d = x.reshape(x.shape[0] * x.shape[1], x.shape[2])
self.__test_1D_2D_sparsity_checking_methods(x_2d) self.__test_1D_2D_sparsity_checking_methods(x_2d)
x = np.random.randint(10, size=(5, 5, 5, 5)) x = np.random.randint(10, size=(5, 5, 5, 5))
x_2d = x.reshape(x.shape[0], x.shape[1] * x.shape[2] * x.shape[3]) x_2d = x.reshape(x.shape[0], x.shape[1] * x.shape[2] * x.shape[3])
self.__test_1D_2D_sparsity_checking_methods(x_2d) self.__test_1D_2D_sparsity_checking_methods(x_2d)
def test_create_mask(self): def test_create_mask(self):
for _ in range(10): for _ in range(10):
x = np.random.randint(10, size=(5)) x = np.random.randint(10, size=(5))
self.__test_1D_2D_sparse_mask_generation_methods(x) self.__test_1D_2D_sparse_mask_generation_methods(x)
x = np.random.randint(10, size=(5, 5)) x = np.random.randint(10, size=(5, 5))
self.__test_1D_2D_sparse_mask_generation_methods(x) self.__test_1D_2D_sparse_mask_generation_methods(x)
x = np.random.randint(10, size=(5, 5, 5)) x = np.random.randint(10, size=(5, 5, 5))
self.__test_1D_2D_sparse_mask_generation_methods(x) self.__test_1D_2D_sparse_mask_generation_methods(x)
x = np.random.randint(10, size=(5, 5, 5, 5)) x = np.random.randint(10, size=(5, 5, 5, 5))
self.__test_1D_2D_sparse_mask_generation_methods(x) self.__test_1D_2D_sparse_mask_generation_methods(x)
def __test_1D_2D_sparsity_checking_methods(self, x_2d): def __test_1D_2D_sparsity_checking_methods(self, x_2d):
mask = paddle.fluid.contrib.sparsity.get_mask_1d(x_2d, 2, 4) mask = paddle.fluid.contrib.sparsity.get_mask_1d(x_2d, 2, 4)
self.assertEqual( self.assertEqual(
paddle.fluid.contrib.sparsity.check_sparsity( paddle.fluid.contrib.sparsity.check_sparsity(
mask, mask,
func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D, func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D,
n=2, n=2,
m=4), paddle.fluid.contrib.sparsity.check_mask_1d(mask, 2, 4)) m=4), paddle.fluid.contrib.sparsity.check_mask_1d(mask, 2, 4))
mask = paddle.fluid.contrib.sparsity.get_mask_2d_best(x_2d, 2, 4) mask = paddle.fluid.contrib.sparsity.get_mask_2d_best(x_2d, 2, 4)
self.assertEqual( self.assertEqual(
paddle.fluid.contrib.sparsity.check_sparsity( paddle.fluid.contrib.sparsity.check_sparsity(
mask, mask,
func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D, func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D,
n=2, n=2,
m=4), paddle.fluid.contrib.sparsity.check_mask_2d(mask, 2, 4)) m=4), paddle.fluid.contrib.sparsity.check_mask_2d(mask, 2, 4))
def __test_1D_2D_sparse_mask_generation_methods(self, x): def __test_1D_2D_sparse_mask_generation_methods(self, x):
mask = paddle.fluid.contrib.sparsity.create_mask( mask = paddle.fluid.contrib.sparsity.create_mask(
x, x,
func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_1D, func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_1D,
n=2, n=2,
m=4) m=4)
self.assertTrue( self.assertTrue(
paddle.fluid.contrib.sparsity.check_sparsity( paddle.fluid.contrib.sparsity.check_sparsity(
mask, mask,
func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D, func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_1D,
n=2, n=2,
m=4)) m=4))
mask = paddle.fluid.contrib.sparsity.create_mask( mask = paddle.fluid.contrib.sparsity.create_mask(
x, x,
func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_GREEDY, func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_GREEDY,
n=2, n=2,
m=4) m=4)
self.assertTrue( self.assertTrue(
paddle.fluid.contrib.sparsity.check_sparsity( paddle.fluid.contrib.sparsity.check_sparsity(
mask, mask,
func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D, func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D,
n=2, n=2,
m=4)) m=4))
mask = paddle.fluid.contrib.sparsity.create_mask( mask = paddle.fluid.contrib.sparsity.create_mask(
x, x,
func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_BEST, func_name=paddle.fluid.contrib.sparsity.MaskAlgo.MASK_2D_BEST,
n=2, n=2,
m=4) m=4)
self.assertTrue( self.assertTrue(
paddle.fluid.contrib.sparsity.check_sparsity( paddle.fluid.contrib.sparsity.check_sparsity(
mask, mask,
func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D, func_name=paddle.fluid.contrib.sparsity.CheckMethod.CHECK_2D,
n=2, n=2,
m=4)) m=4))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
python/paddle/fluid/tests/unittests/mkldnn/test_elementwise_sub_mkldnn_op.py
浏览文件 @ c6c9c186
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from __future__ import print_function from __future__ import print_function
import unittest import unittest
import numpy as np import numpy as np
from paddle import enable_static from paddle import enable_static
from paddle.fluid.tests.unittests.op_test import OpTest, OpTestTool, convert_float_to_uint16 from paddle.fluid.tests.unittests.op_test import OpTest, OpTestTool, convert_float_to_uint16
from paddle.fluid.framework import _current_expected_place from paddle.fluid.framework import _current_expected_place
import paddle.fluid.core as core import paddle.fluid.core as core
@OpTestTool.skip_if(not (isinstance(_current_expected_place(), core.CPUPlace)), @OpTestTool.skip_if(not (isinstance(_current_expected_place(), core.CPUPlace)),
"GPU is not supported") "GPU is not supported")
class TestMKLDNNElementwiseSubOp(OpTest): class TestMKLDNNElementwiseSubOp(OpTest):
def setUp(self): def setUp(self):
self.op_type = "elementwise_sub" self.op_type = "elementwise_sub"
self.init_dtype() self.init_dtype()
self.init_input_output() self.init_input_output()
self.init_kernel_type() self.init_kernel_type()
self.init_axis() self.init_axis()
self.inputs = { self.inputs = {
'X': OpTest.np_dtype_to_fluid_dtype(self.x), 'X': OpTest.np_dtype_to_fluid_dtype(self.x),
'Y': OpTest.np_dtype_to_fluid_dtype(self.y) 'Y': OpTest.np_dtype_to_fluid_dtype(self.y)
} }
self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn} self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn}
self.outputs = {'Out': self.out} self.outputs = {'Out': self.out}
def init_input_output(self): def init_input_output(self):
self.x = np.random.uniform(0.1, 1, [13, 17]).astype(self.dtype) self.x = np.random.uniform(0.1, 1, [13, 17]).astype(self.dtype)
self.y = np.random.uniform(0.1, 1, [13, 17]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [13, 17]).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
def test_check_grad_normal(self): def test_check_grad_normal(self):
self.check_grad(['X', 'Y'], 'Out') self.check_grad(['X', 'Y'], 'Out')
def test_check_grad_ignore_x(self): def test_check_grad_ignore_x(self):
self.check_grad(['Y'], 'Out', no_grad_set=set("X")) self.check_grad(['Y'], 'Out', no_grad_set=set("X"))
def test_check_grad_ignore_y(self): def test_check_grad_ignore_y(self):
self.check_grad(['X'], 'Out', no_grad_set=set('Y')) self.check_grad(['X'], 'Out', no_grad_set=set('Y'))
def init_axis(self): def init_axis(self):
self.axis = -1 self.axis = -1
def init_kernel_type(self): def init_kernel_type(self):
self.use_mkldnn = True self.use_mkldnn = True
def init_dtype(self): def init_dtype(self):
self.dtype = np.float32 self.dtype = np.float32
def test_check_output(self): def test_check_output(self):
self.check_output() self.check_output()
class TestMKLDNNElementwiseSubOp2(TestMKLDNNElementwiseSubOp): class TestMKLDNNElementwiseSubOp2(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.random((100, )).astype(self.dtype) self.x = np.random.random((100, )).astype(self.dtype)
self.y = np.random.random((100, )).astype(self.dtype) self.y = np.random.random((100, )).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
class TestMKLDNNElementwiseSubOp3(TestMKLDNNElementwiseSubOp): class TestMKLDNNElementwiseSubOp3(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.x = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype)
self.y = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype) self.y = np.random.uniform(0.1, 1, [2, 3, 4, 5]).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
class TestMKLDNNElementwiseSubOp4(TestMKLDNNElementwiseSubOp): class TestMKLDNNElementwiseSubOp4(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.uniform(1, 2, [2, 3, 4, 32]).astype(self.dtype) self.x = np.random.uniform(1, 2, [2, 3, 4, 32]).astype(self.dtype)
self.y = np.random.uniform(1, 2, [4, 32]).astype(self.dtype) self.y = np.random.uniform(1, 2, [4, 32]).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
class TestMKLDNNElementwiseSubOp5(TestMKLDNNElementwiseSubOp): class TestMKLDNNElementwiseSubOp5(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype) self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype)
self.y = np.random.uniform(1, 2, [100]).astype(self.dtype) self.y = np.random.uniform(1, 2, [100]).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
class TestMKLDNNElementwiseSubOp_broadcast(TestMKLDNNElementwiseSubOp): class TestMKLDNNElementwiseSubOp_broadcast(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.rand(2, 10, 12, 3).astype(self.dtype) self.x = np.random.rand(2, 10, 12, 3).astype(self.dtype)
self.y = np.random.rand(10, 12).astype(self.dtype) self.y = np.random.rand(10, 12).astype(self.dtype)
self.out = self.x - self.y.reshape(1, 10, 12, 1) self.out = self.x - self.y.reshape(1, 10, 12, 1)
def init_axis(self): def init_axis(self):
self.axis = 1 self.axis = 1
class TestElementwiseSubOp_xsize_lessthan_ysize_sub(TestMKLDNNElementwiseSubOp): class TestElementwiseSubOp_xsize_lessthan_ysize_sub(TestMKLDNNElementwiseSubOp):
def init_input_output(self): def init_input_output(self):
self.x = np.random.rand(10, 12).astype(self.dtype) self.x = np.random.rand(10, 12).astype(self.dtype)
self.y = np.random.rand(2, 2, 10, 12).astype(self.dtype) self.y = np.random.rand(2, 2, 10, 12).astype(self.dtype)
self.out = self.x - self.y self.out = self.x - self.y
def init_axis(self): def init_axis(self):
self.axis = 2 self.axis = 2
def test_check_grad_normal(self): def test_check_grad_normal(self):
pass pass
def test_check_grad_ignore_y(self): def test_check_grad_ignore_y(self):
pass pass
def test_check_grad_ignore_x(self): def test_check_grad_ignore_x(self):
pass pass
@OpTestTool.skip_if_not_cpu_bf16() @OpTestTool.skip_if_not_cpu_bf16()
class TestBf16(TestMKLDNNElementwiseSubOp): class TestBf16(TestMKLDNNElementwiseSubOp):
def setUp(self): def setUp(self):
self.op_type = "elementwise_sub" self.op_type = "elementwise_sub"
self.init_dtype() self.init_dtype()
self.init_input_output() self.init_input_output()
self.init_kernel_type() self.init_kernel_type()
self.init_axis() self.init_axis()
self.x_bf16 = convert_float_to_uint16(self.x) self.x_bf16 = convert_float_to_uint16(self.x)
self.y_bf16 = convert_float_to_uint16(self.y) self.y_bf16 = convert_float_to_uint16(self.y)
self.inputs = {'X': self.x_bf16, 'Y': self.y_bf16} self.inputs = {'X': self.x_bf16, 'Y': self.y_bf16}
self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn} self.attrs = {'axis': self.axis, 'use_mkldnn': self.use_mkldnn}
self.outputs = {'Out': convert_float_to_uint16(self.out)} self.outputs = {'Out': convert_float_to_uint16(self.out)}
def init_dtype(self): def init_dtype(self):
self.dtype = np.float32 self.dtype = np.float32
self.mkldnn_data_type = "bfloat16" self.mkldnn_data_type = "bfloat16"
def init_input_output(self): def init_input_output(self):
self.x = np.random.random(100, ).astype(self.dtype) self.x = np.random.random(100, ).astype(self.dtype)
self.y = np.random.random(100, ).astype(self.dtype) self.y = np.random.random(100, ).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
def test_check_output(self): def test_check_output(self):
self.check_output_with_place(core.CPUPlace()) self.check_output_with_place(core.CPUPlace())
def test_check_grad_normal(self): def test_check_grad_normal(self):
self.check_grad_with_place(core.CPUPlace(), ["X", "Y"], self.check_grad_with_place(core.CPUPlace(), ["X", "Y"],
"Out", "Out",
user_defined_grads=[self.x, -self.x], user_defined_grads=[self.x, -self.x],
user_defined_grad_outputs=[self.x_bf16]) user_defined_grad_outputs=[self.x_bf16])
def test_check_grad_ignore_x(self): def test_check_grad_ignore_x(self):
self.check_grad_with_place(core.CPUPlace(), ["Y"], self.check_grad_with_place(core.CPUPlace(), ["Y"],
"Out", "Out",
user_defined_grads=[-self.y], user_defined_grads=[-self.y],
user_defined_grad_outputs=[self.y_bf16]) user_defined_grad_outputs=[self.y_bf16])
def test_check_grad_ignore_y(self): def test_check_grad_ignore_y(self):
self.check_grad_with_place(core.CPUPlace(), ["X"], self.check_grad_with_place(core.CPUPlace(), ["X"],
"Out", "Out",
user_defined_grads=[self.x], user_defined_grads=[self.x],
user_defined_grad_outputs=[self.x_bf16]) user_defined_grad_outputs=[self.x_bf16])
class TestBf16Broadcasting(TestBf16): class TestBf16Broadcasting(TestBf16):
def init_input_output(self): def init_input_output(self):
self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype) self.x = np.random.uniform(1, 2, [2, 3, 4, 100]).astype(self.dtype)
self.y = np.random.uniform(1, 2, [100]).astype(self.dtype) self.y = np.random.uniform(1, 2, [100]).astype(self.dtype)
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
def compute_reduced_gradients(self, out_grads): def compute_reduced_gradients(self, out_grads):
part_sum = np.add.reduceat(out_grads, [0], axis=0) part_sum = np.add.reduceat(out_grads, [0], axis=0)
part_sum = np.add.reduceat(part_sum, [0], axis=1) part_sum = np.add.reduceat(part_sum, [0], axis=1)
part_sum = np.add.reduceat(part_sum, [0], axis=2) part_sum = np.add.reduceat(part_sum, [0], axis=2)
return -part_sum.flatten() return -part_sum.flatten()
def test_check_grad_normal(self): def test_check_grad_normal(self):
self.check_grad_with_place( self.check_grad_with_place(
core.CPUPlace(), ["X", "Y"], core.CPUPlace(), ["X", "Y"],
"Out", "Out",
user_defined_grads=[self.x, user_defined_grads=[self.x,
self.compute_reduced_gradients(self.x)], self.compute_reduced_gradients(self.x)],
user_defined_grad_outputs=[self.x_bf16]) user_defined_grad_outputs=[self.x_bf16])
def test_check_grad_ignore_x(self): def test_check_grad_ignore_x(self):
self.check_grad_with_place( self.check_grad_with_place(
core.CPUPlace(), ["Y"], core.CPUPlace(), ["Y"],
"Out", "Out",
user_defined_grads=[self.compute_reduced_gradients(self.x)], user_defined_grads=[self.compute_reduced_gradients(self.x)],
user_defined_grad_outputs=[self.x_bf16]) user_defined_grad_outputs=[self.x_bf16])
class TestInt8(TestMKLDNNElementwiseSubOp): class TestInt8(TestMKLDNNElementwiseSubOp):
def init_kernel_type(self): def init_kernel_type(self):
self.use_mkldnn = True self.use_mkldnn = True
self._cpu_only = True self._cpu_only = True
def init_dtype(self): def init_dtype(self):
self.dtype = np.int8 self.dtype = np.int8
def init_input_output(self): def init_input_output(self):
self.x = np.random.randint(0, 3, (12, 9)).astype("int8") self.x = np.random.randint(0, 3, (12, 9)).astype("int8")
self.y = np.random.randint(0, 3, (12, 9)).astype("int8") self.y = np.random.randint(0, 3, (12, 9)).astype("int8")
self.out = np.subtract(self.x, self.y) self.out = np.subtract(self.x, self.y)
def init_scales(self): def init_scales(self):
self.attrs['Scale_x'] = 1.0 self.attrs['Scale_x'] = 1.0
self.attrs['Scale_y'] = 1.0 self.attrs['Scale_y'] = 1.0
self.attrs['Scale_out'] = 1.0 self.attrs['Scale_out'] = 1.0
def test_check_output(self): def test_check_output(self):
self.init_scales() self.init_scales()
self.check_output() self.check_output()
def test_check_grad_normal(self): def test_check_grad_normal(self):
pass pass
def test_check_grad_ignore_x(self): def test_check_grad_ignore_x(self):
pass pass
def test_check_grad_ignore_y(self): def test_check_grad_ignore_y(self):
pass pass
if __name__ == '__main__': if __name__ == '__main__':
enable_static() enable_static()
unittest.main() unittest.main()
python/paddle/fluid/tests/unittests/mkldnn/test_fill_constant_mkldnn_op.py
浏览文件 @ c6c9c186
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from __future__ import print_function from __future__ import print_function
import unittest import unittest
import numpy as np import numpy as np
from paddle.fluid.tests.unittests.op_test import OpTest, OpTestTool from paddle.fluid.tests.unittests.op_test import OpTest, OpTestTool
import paddle import paddle
@OpTestTool.skip_if_not_cpu_bf16() @OpTestTool.skip_if_not_cpu_bf16()
class TestFillConstant2DOneDNNOp(OpTest): class TestFillConstant2DOneDNNOp(OpTest):
def setUp(self): def setUp(self):
self.op_type = "fill_constant" self.op_type = "fill_constant"
self.dtype = np.float32 self.dtype = np.float32
self.shape_tensor_list = None self.shape_tensor_list = None
self.shape_tensor = None self.shape_tensor = None
self.str_value = "" self.str_value = ""
real_shape = [] real_shape = []
self.value = 0.1 self.value = 0.1
self.set_inputs() self.set_inputs()
self.set_attrs() self.set_attrs()
if 'value' in self.attrs: if 'value' in self.attrs:
self.value = self.attrs['value'] self.value = self.attrs['value']
if self.str_value != "": if self.str_value != "":
self.value = float(self.str_value) self.value = float(self.str_value)
if 'ValueTensor' in self.inputs: if 'ValueTensor' in self.inputs:
self.value = self.inputs['ValueTensor'] self.value = self.inputs['ValueTensor']
if 'shape' in self.attrs: if 'shape' in self.attrs:
real_shape = self.attrs['shape'] real_shape = self.attrs['shape']
if 'ShapeTensor' in self.inputs: if 'ShapeTensor' in self.inputs:
real_shape = list(self.inputs['ShapeTensor']) real_shape = list(self.inputs['ShapeTensor'])
if 'ShapeTensorList' in self.inputs: if 'ShapeTensorList' in self.inputs:
real_shape = [] real_shape = []
for shape_tensor in self.inputs['ShapeTensorList']: for shape_tensor in self.inputs['ShapeTensorList']:
real_shape.append(shape_tensor[1].item()) real_shape.append(shape_tensor[1].item())
self.outputs = {'Out': np.full(real_shape, self.value)} self.outputs = {'Out': np.full(real_shape, self.value)}
def set_inputs(self): def set_inputs(self):
self.inputs = {} self.inputs = {}
def set_attrs(self): def set_attrs(self):
self.attrs = {'shape': (3, 5), 'use_mkldnn': True, 'value': self.value} self.attrs = {'shape': (3, 5), 'use_mkldnn': True, 'value': self.value}
def test_check_output(self): def test_check_output(self):
self.check_output() self.check_output()
class TestFillZerosLike4DShapeTensorPriorityOneDNNOp(TestFillConstant2DOneDNNOp class TestFillZerosLike4DShapeTensorPriorityOneDNNOp(TestFillConstant2DOneDNNOp
): ):
def set_inputs(self): def set_inputs(self):
self.inputs = {'ShapeTensor': np.array([5, 6, 7, 8]).astype("int32")} self.inputs = {'ShapeTensor': np.array([5, 6, 7, 8]).astype("int32")}
class TestFillZerosLike4DShapeTensorListPriorityOneDNNOp( class TestFillZerosLike4DShapeTensorListPriorityOneDNNOp(
TestFillConstant2DOneDNNOp): TestFillConstant2DOneDNNOp):
def set_inputs(self): def set_inputs(self):
shape = (4, 5, 6, 7) shape = (4, 5, 6, 7)
self.shape_tensor_list = [] self.shape_tensor_list = []
for index, elem in enumerate(shape): for index, elem in enumerate(shape):
self.shape_tensor_list.append(("x" + str(index), np.ones( self.shape_tensor_list.append(("x" + str(index), np.ones(
(1)).astype('int32') * elem)) (1)).astype('int32') * elem))
self.inputs = {'ShapeTensorList': self.shape_tensor_list} self.inputs = {'ShapeTensorList': self.shape_tensor_list}
class TestFillZerosLike2DStringValueInfOneDNNOp(TestFillConstant2DOneDNNOp): class TestFillZerosLike2DStringValueInfOneDNNOp(TestFillConstant2DOneDNNOp):
def set_attrs(self): def set_attrs(self):
self.str_value = "inf" self.str_value = "inf"
self.attrs = {'shape': (10, 13), 'use_mkldnn': True, 'str_value': "inf"} self.attrs = {'shape': (10, 13), 'use_mkldnn': True, 'str_value': "inf"}
class TestFillZerosLike2DStringValueMinusInfOneDNNOp(TestFillConstant2DOneDNNOp class TestFillZerosLike2DStringValueMinusInfOneDNNOp(TestFillConstant2DOneDNNOp
): ):
def set_attrs(self): def set_attrs(self):
self.str_value = "-inf" self.str_value = "-inf"
self.attrs = { self.attrs = {
'shape': (10, 13), 'shape': (10, 13),
'use_mkldnn': True, 'use_mkldnn': True,
'str_value': "-inf" 'str_value': "-inf"
} }
class TestFillZerosLike2DStringValueFloatOneDNNOp(TestFillConstant2DOneDNNOp): class TestFillZerosLike2DStringValueFloatOneDNNOp(TestFillConstant2DOneDNNOp):
def set_attrs(self): def set_attrs(self):
self.str_value = "0.123" self.str_value = "0.123"
self.attrs = { self.attrs = {
'shape': (10, 13), 'shape': (10, 13),
'use_mkldnn': True, 'use_mkldnn': True,
'str_value': "0.123" 'str_value': "0.123"
} }
class TestFillZerosLike2DValueTensorPriorityOneDNNOp( class TestFillZerosLike2DValueTensorPriorityOneDNNOp(
TestFillZerosLike2DStringValueFloatOneDNNOp): TestFillZerosLike2DStringValueFloatOneDNNOp):
def set_inputs(self): def set_inputs(self):
self.inputs = {'ValueTensor': np.atleast_1d(2.25).astype("float32")} self.inputs = {'ValueTensor': np.atleast_1d(2.25).astype("float32")}
if __name__ == "__main__": if __name__ == "__main__":
paddle.enable_static() paddle.enable_static()
unittest.main() unittest.main()
python/paddle/fluid/tests/unittests/sequence/test_sequence_first_step.py
浏览文件 @ c6c9c186
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import paddle.fluid as fluid import paddle.fluid as fluid
from paddle.fluid.framework import convert_np_dtype_to_dtype_, Program, program_guard from paddle.fluid.framework import convert_np_dtype_to_dtype_, Program, program_guard
import paddle.fluid.core as core import paddle.fluid.core as core
import numpy as np import numpy as np
import copy import copy
import unittest import unittest
import sys import sys
sys.path.append("../") sys.path.append("../")
from op_test import OpTest from op_test import OpTest
class TestSequenceFirstStepOpError(unittest.TestCase): class TestSequenceFirstStepOpError(unittest.TestCase):
def test_errors(self): def test_errors(self):
with program_guard(Program(), Program()): with program_guard(Program(), Program()):
def test_Variable(): def test_Variable():
# the input must be Variable # the input must be Variable
input_data = np.random.randint(1, 5, [4]).astype("int64") input_data = np.random.randint(1, 5, [4]).astype("int64")
fluid.layers.sequence_last_step(input_data) fluid.layers.sequence_last_step(input_data)
self.assertRaises(TypeError, test_Variable) self.assertRaises(TypeError, test_Variable)
def test_input_dtype(): def test_input_dtype():
# the dtype of input must be int64 # the dtype of input must be int64
type_data = fluid.layers.data(name='type_data', type_data = fluid.layers.data(name='type_data',
shape=[7, 1], shape=[7, 1],
append_batch_size=False, append_batch_size=False,
dtype='int64', dtype='int64',
lod_level=1) lod_level=1)
fluid.layers.sequence_last_step(type_data) fluid.layers.sequence_last_step(type_data)
self.assertRaises(TypeError, test_input_dtype) self.assertRaises(TypeError, test_input_dtype)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
python/paddle/fluid/tests/unittests/sequence/test_sequence_last_step.py
浏览文件 @ c6c9c186
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import paddle.fluid as fluid import paddle.fluid as fluid
from paddle.fluid.framework import convert_np_dtype_to_dtype_, Program, program_guard from paddle.fluid.framework import convert_np_dtype_to_dtype_, Program, program_guard
import paddle.fluid.core as core import paddle.fluid.core as core
import numpy as np import numpy as np
import copy import copy
import unittest import unittest
import sys import sys
sys.path.append("../") sys.path.append("../")
from op_test import OpTest from op_test import OpTest
class TestSequenceLastStepOpError(unittest.TestCase): class TestSequenceLastStepOpError(unittest.TestCase):
def test_errors(self): def test_errors(self):
with program_guard(Program(), Program()): with program_guard(Program(), Program()):
def test_Variable(): def test_Variable():
# the input must be Variable # the input must be Variable
input_data = np.random.randint(1, 5, [4]).astype("int64") input_data = np.random.randint(1, 5, [4]).astype("int64")
fluid.layers.sequence_last_step(input_data) fluid.layers.sequence_last_step(input_data)
self.assertRaises(TypeError, test_Variable) self.assertRaises(TypeError, test_Variable)
def test_input_dtype(): def test_input_dtype():
# the dtype of input must be int64 # the dtype of input must be int64
type_data = fluid.layers.data(name='type_data', type_data = fluid.layers.data(name='type_data',
shape=[7, 1], shape=[7, 1],
append_batch_size=False, append_batch_size=False,
dtype='int64', dtype='int64',
lod_level=1) lod_level=1)
fluid.layers.sequence_last_step(type_data) fluid.layers.sequence_last_step(type_data)
self.assertRaises(TypeError, test_input_dtype) self.assertRaises(TypeError, test_input_dtype)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
python/paddle/fluid/tests/unittests/test_rnn_op.py
浏览文件 @ c6c9c186
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. # Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. # you may not use this file except in compliance with the License.
# You may obtain a copy of the License at # You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, # distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from __future__ import print_function from __future__ import print_function
import unittest import unittest
import numpy as np import numpy as np
import math import math
import paddle.fluid.core as core import paddle.fluid.core as core
import paddle import paddle
import paddle.fluid as fluid import paddle.fluid as fluid
import paddle.fluid.layers as layers import paddle.fluid.layers as layers
import random import random
import sys import sys
from op_test import OpTest from op_test import OpTest
sys.path.append("./rnn") sys.path.append("./rnn")
from rnn_numpy import SimpleRNN, LSTM, GRU from rnn_numpy import SimpleRNN, LSTM, GRU
from convert import get_params_for_net from convert import get_params_for_net
random.seed(2) random.seed(2)
np.set_printoptions(threshold=np.inf) np.set_printoptions(threshold=np.inf)
paddle.enable_static() paddle.enable_static()
class TestRNNOp(OpTest): class TestRNNOp(OpTest):
def get_weight_names(self): def get_weight_names(self):
weight_names = [] weight_names = []
for i in range(self.num_layers): for i in range(self.num_layers):
for j in range(0, 2 * self.direction_num): for j in range(0, 2 * self.direction_num):
weight_names.append("{}.weight_{}".format(i, j)) weight_names.append("{}.weight_{}".format(i, j))
for i in range(self.num_layers): for i in range(self.num_layers):
for j in range(0, 2 * self.direction_num): for j in range(0, 2 * self.direction_num):
weight_names.append("{}.bias_{}".format(i, j)) weight_names.append("{}.bias_{}".format(i, j))
return weight_names return weight_names
def setUp(self): def setUp(self):
self.op_type = "rnn" self.op_type = "rnn"
self.dtype = np.float32 if core.is_compiled_with_rocm() else np.float64 self.dtype = np.float32 if core.is_compiled_with_rocm() else np.float64
self.sequence_length = None if core.is_compiled_with_rocm( self.sequence_length = None if core.is_compiled_with_rocm(
) else np.array([12, 11, 10, 9, 8], dtype=np.int32) ) else np.array([12, 11, 10, 9, 8], dtype=np.int32)
self.num_layers = 1 self.num_layers = 1
self.is_bidirec = False self.is_bidirec = False
self.mode = "LSTM" self.mode = "LSTM"
self.is_test = False self.is_test = False
self.dropout = 0.0 self.dropout = 0.0
self.set_attrs() self.set_attrs()
self.direction_num = 2 if self.is_bidirec else 1 self.direction_num = 2 if self.is_bidirec else 1
direction = "bidirectional" if self.is_bidirec else "forward" direction = "bidirectional" if self.is_bidirec else "forward"
seq_length = 12 seq_length = 12
batch_size = 5 batch_size = 5
input_size = 3 input_size = 3
hidden_size = 2 hidden_size = 2
input = np.random.uniform(low=-0.1, input = np.random.uniform(low=-0.1,
high=0.1, high=0.1,
size=(seq_length, batch_size, size=(seq_length, batch_size,
input_size)).astype(self.dtype) input_size)).astype(self.dtype)
if self.sequence_length is not None: if self.sequence_length is not None:
input[11][1:][:] = 0 input[11][1:][:] = 0
input[10][2:][:] = 0 input[10][2:][:] = 0
input[9][3:][:] = 0 input[9][3:][:] = 0
input[8][4:][:] = 0 input[8][4:][:] = 0
rnn1 = LSTM(input_size, rnn1 = LSTM(input_size,
hidden_size, hidden_size,
num_layers=self.num_layers, num_layers=self.num_layers,
time_major=True, time_major=True,
direction=direction, direction=direction,
dropout=self.dropout, dropout=self.dropout,
dtype=self.dtype) dtype=self.dtype)
flat_w = get_params_for_net(rnn1) flat_w = get_params_for_net(rnn1)
output, (last_hidden, output, (last_hidden,
last_cell) = rnn1(input, sequence_length=self.sequence_length) last_cell) = rnn1(input, sequence_length=self.sequence_length)
if core.is_compiled_with_rocm(): if core.is_compiled_with_rocm():
def rocm_rnn_get_place(): def rocm_rnn_get_place():
places = [core.CUDAPlace(0)] places = [core.CUDAPlace(0)]
return places return places
self._get_places = rocm_rnn_get_place self._get_places = rocm_rnn_get_place
init_h = np.zeros((self.num_layers * self.direction_num, batch_size, init_h = np.zeros((self.num_layers * self.direction_num, batch_size,
hidden_size)).astype(self.dtype) hidden_size)).astype(self.dtype)
init_c = np.zeros((self.num_layers * self.direction_num, batch_size, init_c = np.zeros((self.num_layers * self.direction_num, batch_size,
hidden_size)).astype(self.dtype) hidden_size)).astype(self.dtype)
state_out = np.ndarray((300)).astype("uint8") state_out = np.ndarray((300)).astype("uint8")
self.inputs = { self.inputs = {
'Input': input, 'Input': input,
'WeightList': flat_w, 'WeightList': flat_w,
'PreState': [('init_h', init_h), ('init_c', init_c)], 'PreState': [('init_h', init_h), ('init_c', init_c)],
'SequenceLength': self.sequence_length 'SequenceLength': self.sequence_length
} }
if self.sequence_length is None: if self.sequence_length is None:
self.inputs = { self.inputs = {
'Input': input, 'Input': input,
'WeightList': flat_w, 'WeightList': flat_w,
'PreState': [('init_h', init_h), ('init_c', init_c)], 'PreState': [('init_h', init_h), ('init_c', init_c)],
} }
self.attrs = { self.attrs = {
'dropout_prob': self.dropout, 'dropout_prob': self.dropout,
'is_bidirec': self.is_bidirec, 'is_bidirec': self.is_bidirec,
'input_size': input_size, 'input_size': input_size,
'hidden_size': hidden_size, 'hidden_size': hidden_size,
'num_layers': self.num_layers, 'num_layers': self.num_layers,
'mode': self.mode, 'mode': self.mode,
'is_test': self.is_test 'is_test': self.is_test
} }
self.outputs = { self.outputs = {
'Out': output, 'Out': output,
"State": [('last_hidden', last_hidden), ('last_cell', last_cell)], "State": [('last_hidden', last_hidden), ('last_cell', last_cell)],
'Reserve': np.ndarray((400)).astype("uint8"), 'Reserve': np.ndarray((400)).astype("uint8"),
'DropoutState': state_out 'DropoutState': state_out
} }
def test_output(self): def test_output(self):
self.check_output(no_check_set=['Reserve', 'DropoutState']) self.check_output(no_check_set=['Reserve', 'DropoutState'])
def set_attrs(self): def set_attrs(self):
pass pass
def test_grad(self): def test_grad(self):
if not self.is_test: if not self.is_test:
var_name_list = self.get_weight_names() var_name_list = self.get_weight_names()
grad_check_list = ['Input', 'init_h', 'init_c'] grad_check_list = ['Input', 'init_h', 'init_c']
grad_check_list.extend(var_name_list) grad_check_list.extend(var_name_list)
self.check_grad(set(grad_check_list), self.check_grad(set(grad_check_list),
['Out', 'last_hidden', 'last_cell']) ['Out', 'last_hidden', 'last_cell'])
class TestRNNOp1(TestRNNOp): class TestRNNOp1(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.sequence_length = None self.sequence_length = None
class TestRNNOp2(TestRNNOp): class TestRNNOp2(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.sequence_length = None self.sequence_length = None
self.is_bidirec = True self.is_bidirec = True
class TestRNNOp3(TestRNNOp): class TestRNNOp3(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.is_test = True self.is_test = True
self.sequence_length = None self.sequence_length = None
class TestRNNOp4(TestRNNOp): class TestRNNOp4(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.is_test = True self.is_test = True
self.sequence_length = None self.sequence_length = None
self.is_bidirec = True self.is_bidirec = True
class TestRNNOp5(TestRNNOp): class TestRNNOp5(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.num_layers = 2 self.num_layers = 2
class TestRNNOp6(TestRNNOp): class TestRNNOp6(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.num_layers = 2 self.num_layers = 2
self.is_bidirec = True self.is_bidirec = True
class TestRNNOp7(TestRNNOp): class TestRNNOp7(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.num_layers = 2 self.num_layers = 2
self.is_bidirec = True self.is_bidirec = True
self.is_test = True self.is_test = True
class TestRNNOp8(TestRNNOp): class TestRNNOp8(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.num_layers = 2 self.num_layers = 2
self.is_bidirec = True self.is_bidirec = True
self.sequence_length = None self.sequence_length = None
class TestRNNOp9(TestRNNOp): class TestRNNOp9(TestRNNOp):
def set_attrs(self): def set_attrs(self):
self.num_layers = 3 self.num_layers = 3
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
python/paddle/fluid/transpiler/memory_optimization_transpiler.py
浏览文件 @ c6c9c186
...@@ -21,7 +21,7 @@ def memory_optimize(input_program, ...@@ -21,7 +21,7 @@ def memory_optimize(input_program,
level=0, level=0,
skip_grads=True): skip_grads=True):
""" """
:api_attr: Static Graph :api_attr: Static Graph
This API is deprecated since 1.6. Please do not use it. The better This API is deprecated since 1.6. Please do not use it. The better
memory optimization strategies are enabled by default. memory optimization strategies are enabled by default.
...@@ -43,7 +43,7 @@ def memory_optimize(input_program, ...@@ -43,7 +43,7 @@ def memory_optimize(input_program,
def release_memory(input_program, skip_opt_set=None): def release_memory(input_program, skip_opt_set=None):
""" """
:api_attr: Static Graph :api_attr: Static Graph
This API is deprecated since 1.6. Please do not use it. The better This API is deprecated since 1.6. Please do not use it. The better
memory optimization strategies are enabled by default. memory optimization strategies are enabled by default.
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或