test_logical_op.py 8.9 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
D
dzhwinter 已提交
2
#
D
dzhwinter 已提交
3 4 5
# 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
D
dzhwinter 已提交
6
#
D
dzhwinter 已提交
7
#     http://www.apache.org/licenses/LICENSE-2.0
D
dzhwinter 已提交
8
#
D
dzhwinter 已提交
9 10 11 12 13 14
# 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.

15 16
import unittest
import numpy as np
17
import paddle
18 19
from paddle.static import Program, program_guard, Executor
from paddle.framework import _non_static_mode
H
hong 已提交
20
from paddle.fluid.framework import _test_eager_guard
21

22 23 24 25
SUPPORTED_DTYPES = [
    bool, np.int8, np.int16, np.int32, np.int64, np.float32, np.float64
]

26 27 28 29 30 31 32 33 34 35 36 37 38
TEST_META_OP_DATA = [{
    'op_str': 'logical_and',
    'binary_op': True
}, {
    'op_str': 'logical_or',
    'binary_op': True
}, {
    'op_str': 'logical_xor',
    'binary_op': True
}, {
    'op_str': 'logical_not',
    'binary_op': False
}]
39

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
TEST_META_SHAPE_DATA = {
    'XDimLargerThanYDim1': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [4, 5]
    },
    'XDimLargerThanYDim2': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [4, 1]
    },
    'XDimLargerThanYDim3': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [1, 4, 1]
    },
    'XDimLargerThanYDim4': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [3, 4, 1]
    },
    'XDimLargerThanYDim5': {
        'x_shape': [2, 3, 1, 5],
        'y_shape': [3, 1, 1]
    },
    'XDimLessThanYDim1': {
        'x_shape': [4, 1],
        'y_shape': [2, 3, 4, 5]
    },
    'XDimLessThanYDim2': {
        'x_shape': [1, 4, 1],
        'y_shape': [2, 3, 4, 5]
    },
    'XDimLessThanYDim3': {
        'x_shape': [3, 4, 1],
        'y_shape': [2, 3, 4, 5]
    },
    'XDimLessThanYDim4': {
        'x_shape': [3, 1, 1],
        'y_shape': [2, 3, 1, 5]
    },
    'XDimLessThanYDim5': {
        'x_shape': [4, 5],
        'y_shape': [2, 3, 4, 5]
    },
    'Axis1InLargerDim': {
        'x_shape': [1, 4, 5],
        'y_shape': [2, 3, 1, 5]
    },
    'EqualDim1': {
        'x_shape': [10, 7],
        'y_shape': [10, 7]
    },
    'EqualDim2': {
        'x_shape': [1, 1, 4, 5],
        'y_shape': [2, 3, 1, 5]
    }
}

TEST_META_WRONG_SHAPE_DATA = {
    'ErrorDim1': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [3, 4]
    },
    'ErrorDim2': {
        'x_shape': [2, 3, 4, 5],
        'y_shape': [4, 3]
    }
}


def run_static(x_np, y_np, op_str, use_gpu=False, binary_op=True):
    paddle.enable_static()
109 110
    startup_program = Program()
    main_program = Program()
111
    place = paddle.CPUPlace()
112
    if use_gpu and paddle.is_compiled_with_cuda():
113
        place = paddle.CUDAPlace(0)
114 115
    exe = Executor(place)
    with program_guard(main_program, startup_program):
116
        x = paddle.static.data(name='x', shape=x_np.shape, dtype=x_np.dtype)
117 118 119 120 121
        op = getattr(paddle, op_str)
        feed_list = {'x': x_np}
        if not binary_op:
            res = op(x)
        else:
122
            y = paddle.static.data(name='y', shape=y_np.shape, dtype=y_np.dtype)
123 124 125 126 127 128 129 130 131
            feed_list['y'] = y_np
            res = op(x, y)
        exe.run(startup_program)
        static_result = exe.run(main_program, feed=feed_list, fetch_list=[res])
    return static_result


def run_dygraph(x_np, y_np, op_str, use_gpu=False, binary_op=True):
    place = paddle.CPUPlace()
132
    if use_gpu and paddle.is_compiled_with_cuda():
133 134 135
        place = paddle.CUDAPlace(0)
    paddle.disable_static(place)
    op = getattr(paddle, op_str)
136
    x = paddle.to_tensor(x_np, dtype=x_np.dtype)
137 138 139
    if not binary_op:
        dygraph_result = op(x)
    else:
140
        y = paddle.to_tensor(y_np, dtype=y_np.dtype)
141 142 143 144
        dygraph_result = op(x, y)
    return dygraph_result


H
hong 已提交
145 146
def run_eager(x_np, y_np, op_str, use_gpu=False, binary_op=True):
    place = paddle.CPUPlace()
147
    if use_gpu and paddle.is_compiled_with_cuda():
H
hong 已提交
148 149 150 151 152 153 154 155 156 157 158 159 160
        place = paddle.CUDAPlace(0)
    paddle.disable_static(place)
    with _test_eager_guard():
        op = getattr(paddle, op_str)
        x = paddle.to_tensor(x_np, dtype=x_np.dtype)
        if not binary_op:
            dygraph_result = op(x)
        else:
            y = paddle.to_tensor(y_np, dtype=y_np.dtype)
            dygraph_result = op(x, y)
        return dygraph_result


161 162 163 164 165
def np_data_generator(np_shape, dtype, *args, **kwargs):
    if dtype == bool:
        return np.random.choice(a=[True, False], size=np_shape).astype(bool)
    else:
        return np.random.randn(*np_shape).astype(dtype)
166 167 168 169 170 171 172 173 174 175 176


def test(unit_test, use_gpu=False, test_error=False):
    for op_data in TEST_META_OP_DATA:
        meta_data = dict(op_data)
        meta_data['use_gpu'] = use_gpu
        np_op = getattr(np, meta_data['op_str'])
        META_DATA = dict(TEST_META_SHAPE_DATA)
        if test_error:
            META_DATA = dict(TEST_META_WRONG_SHAPE_DATA)
        for shape_data in META_DATA.values():
177
            for data_type in SUPPORTED_DTYPES:
178 179 180 181
                meta_data['x_np'] = np_data_generator(shape_data['x_shape'],
                                                      dtype=data_type)
                meta_data['y_np'] = np_data_generator(shape_data['y_shape'],
                                                      dtype=data_type)
182 183 184 185 186 187 188 189 190
                if meta_data['binary_op'] and test_error:
                    # catch C++ Exception
                    unit_test.assertRaises(BaseException, run_static,
                                           **meta_data)
                    unit_test.assertRaises(BaseException, run_dygraph,
                                           **meta_data)
                    continue
                static_result = run_static(**meta_data)
                dygraph_result = run_dygraph(**meta_data)
H
hong 已提交
191
                eager_result = run_eager(**meta_data)
192 193 194 195 196
                if meta_data['binary_op']:
                    np_result = np_op(meta_data['x_np'], meta_data['y_np'])
                else:
                    np_result = np_op(meta_data['x_np'])
                unit_test.assertTrue((static_result == np_result).all())
197 198
                unit_test.assertTrue(
                    (dygraph_result.numpy() == np_result).all())
H
hong 已提交
199
                unit_test.assertTrue((eager_result.numpy() == np_result).all())
200 201 202


def test_type_error(unit_test, use_gpu, type_str_map):
203

204 205
    def check_type(op_str, x, y, binary_op):
        op = getattr(paddle, op_str)
206
        error_type = ValueError
207 208 209 210 211
        if isinstance(x, np.ndarray):
            x = paddle.to_tensor(x)
            y = paddle.to_tensor(y)
            error_type = BaseException
        if binary_op:
212
            if type_str_map['x'] != type_str_map['y']:
213
                unit_test.assertRaises(error_type, op, x=x, y=y)
214
            if not _non_static_mode():
215
                error_type = TypeError
216 217
                unit_test.assertRaises(error_type, op, x=x, y=y, out=1)
        else:
218
            if not _non_static_mode():
219
                error_type = TypeError
220 221 222
                unit_test.assertRaises(error_type, op, x=x, out=1)

    place = paddle.CPUPlace()
223
    if use_gpu and paddle.is_compiled_with_cuda():
224 225 226 227 228 229 230 231 232 233 234 235 236 237
        place = paddle.CUDAPlace(0)
    for op_data in TEST_META_OP_DATA:
        meta_data = dict(op_data)
        binary_op = meta_data['binary_op']

        paddle.disable_static(place)
        x = np.random.choice(a=[0, 1], size=[10]).astype(type_str_map['x'])
        y = np.random.choice(a=[0, 1], size=[10]).astype(type_str_map['y'])
        check_type(meta_data['op_str'], x, y, binary_op)

        paddle.enable_static()
        startup_program = paddle.static.Program()
        main_program = paddle.static.Program()
        with paddle.static.program_guard(main_program, startup_program):
238 239 240 241 242 243
            x = paddle.static.data(name='x',
                                   shape=[10],
                                   dtype=type_str_map['x'])
            y = paddle.static.data(name='y',
                                   shape=[10],
                                   dtype=type_str_map['y'])
244 245 246 247 248 249 250
            check_type(meta_data['op_str'], x, y, binary_op)


def type_map_factory():
    return [{
        'x': x_type,
        'y': y_type
251
    } for x_type in SUPPORTED_DTYPES for y_type in SUPPORTED_DTYPES]
252 253 254


class TestCPU(unittest.TestCase):
255

256 257 258 259 260 261 262 263 264 265 266 267 268
    def test(self):
        test(self)

    def test_error(self):
        test(self, False, True)

    def test_type_error(self):
        type_map_list = type_map_factory()
        for type_map in type_map_list:
            test_type_error(self, False, type_map)


class TestCUDA(unittest.TestCase):
269

270 271 272 273 274 275 276 277 278 279 280
    def test(self):
        test(self, True)

    def test_error(self):
        test(self, True, True)

    def test_type_error(self):
        type_map_list = type_map_factory()
        for type_map in type_map_list:
            test_type_error(self, True, type_map)

281 282

if __name__ == '__main__':
H
hong 已提交
283
    paddle.enable_static()
284
    unittest.main()