op_test.py 100.6 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
from __future__ import print_function

B
baojun 已提交
17
import os
18
import sys
19
import unittest
20
import warnings
21
import numpy as np
22
import random
M
minqiyang 已提交
23
import six
24
import struct
25
import time
26
import itertools
Y
Yu Yang 已提交
27
import collections
M
minqiyang 已提交
28
from collections import defaultdict
29
from copy import copy
30

31
import paddle
32
import paddle.fluid as fluid
33
from paddle.fluid.framework import _dygraph_tracer
34
import paddle.fluid.core as core
J
Jiabin Yang 已提交
35
from paddle.fluid.framework import _in_legacy_dygraph, _enable_legacy_dygraph, _in_eager_without_dygraph_check, _disable_legacy_dygraph
36
from paddle.fluid.framework import _test_eager_guard
37 38 39
from paddle.fluid.backward import append_backward
from paddle.fluid.op import Operator
from paddle.fluid.executor import Executor
A
arlesniak 已提交
40
from paddle.fluid.framework import Program, OpProtoHolder, Variable, _current_expected_place
41 42 43 44 45
from paddle.fluid import unique_name
from paddle.fluid.dygraph.dygraph_to_static.utils import parse_arg_and_kwargs

sys.path.append(os.path.abspath(os.path.dirname(__file__)))
from testsuite import (
46 47 48
    create_op,
    set_input,
    append_input_output,
49 50
    append_loss_ops,
)
51
from white_list import (
52 53 54 55 56
    op_accuracy_white_list,
    check_shape_white_list,
    compile_vs_runtime_white_list,
    no_check_set_white_list,
    op_threshold_white_list,
57 58
    no_grad_set_white_list,
)
59

60 61 62 63 64
# For switch new eager mode globally
g_is_in_eager = _in_eager_without_dygraph_check()
g_enable_legacy_dygraph = _enable_legacy_dygraph if g_is_in_eager else lambda: None
g_disable_legacy_dygraph = _disable_legacy_dygraph if g_is_in_eager else lambda: None

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
def check_out_dtype(api_fn, in_specs, expect_dtypes, target_index=0, **configs):
    """
    Determines whether dtype of output tensor is as expected.

    Args:
        api_fn(callable):  paddle api function
        in_specs(list[tuple]): list of shape and dtype information for constructing input tensor of api_fn, such as [(shape, dtype), (shape, dtype)].
        expected_dtype(list[str]): expected dtype of output tensor.
        target_index(int): indicate which one from in_specs to infer the dtype of output.
        config(dict): other arguments of paddle api function

    Example:
        check_out_dtype(fluid.layers.pad_constant_like, [([2,3,2,3], 'float64'), ([1, 3, 1,3], )], ['float32', 'float64', 'int64'], target_index=1, pad_value=0.)

    """
    paddle.enable_static()
    for i, expect_dtype in enumerate(expect_dtypes):
        with paddle.static.program_guard(paddle.static.Program()):
            input_t = []
            for index, spec in enumerate(in_specs):
                if len(spec) == 1:
                    shape = spec[0]
                    dtype = expect_dtype if target_index == index else 'float32'
                elif len(spec) == 2:
                    shape, dtype = spec
                else:
                    raise ValueError(
93 94
                        "Value of in_specs[{}] should contains two elements: [shape, dtype]"
                        .format(index))
95
                input_t.append(
96 97 98
                    paddle.static.data(name='data_%s' % index,
                                       shape=shape,
                                       dtype=dtype))
99 100 101 102 103 104 105 106 107 108

            out = api_fn(*input_t, **configs)
            out_dtype = fluid.data_feeder.convert_dtype(out.dtype)

            if out_dtype != expect_dtype:
                raise ValueError(
                    "Expected out.dtype is {}, but got {} from {}.".format(
                        expect_dtype, out_dtype, api_fn.__name__))


109 110 111 112 113 114 115 116
def _set_use_system_allocator(value=None):
    USE_SYSTEM_ALLOCATOR_FLAG = "FLAGS_use_system_allocator"
    old_value = core.globals()[USE_SYSTEM_ALLOCATOR_FLAG]
    value = old_value if value is None else value
    core.globals()[USE_SYSTEM_ALLOCATOR_FLAG] = value
    return old_value


117
def randomize_probability(batch_size, class_num, dtype='float32'):
118 119
    prob = np.random.uniform(0.1, 1.0,
                             size=(batch_size, class_num)).astype(dtype)
120
    prob_sum = prob.sum(axis=1)
M
minqiyang 已提交
121
    for i in six.moves.xrange(len(prob)):
122 123 124 125
        prob[i] /= prob_sum[i]
    return prob


126 127
def get_numeric_gradient(place,
                         scope,
128 129 130
                         op,
                         inputs,
                         input_to_check,
Y
Yancey 已提交
131
                         output_names,
132
                         delta=0.005,
C
chengduo 已提交
133
                         in_place=False):
Y
Yu Yang 已提交
134
    # FIXME: change this method by compile time concepts
135
    set_input(scope, op, inputs, place)
136 137

    def product(dim):
M
minqiyang 已提交
138
        return six.moves.reduce(lambda a, b: a * b, dim, 1)
139 140

    tensor_to_check = scope.find_var(input_to_check).get_tensor()
Y
yuyang18 已提交
141 142
    tensor_size = product(tensor_to_check.shape())
    tensor_to_check_dtype = tensor_to_check._dtype()
143
    if tensor_to_check_dtype == core.VarDesc.VarType.FP32:
144
        tensor_to_check_dtype = np.float32
145
    elif tensor_to_check_dtype == core.VarDesc.VarType.FP64:
146
        tensor_to_check_dtype = np.float64
D
dzhwinter 已提交
147 148 149 150
    elif tensor_to_check_dtype == core.VarDesc.VarType.FP16:
        tensor_to_check_dtype = np.float16
        # set delta as np.float16, will automatic convert to float32, float64
        delta = np.array(delta).astype(np.float16)
151 152
    elif tensor_to_check_dtype == core.VarDesc.VarType.BF16:
        tensor_to_check_dtype = np.float32
L
Lijunhui 已提交
153 154 155 156
    elif tensor_to_check_dtype == core.VarDesc.VarType.COMPLEX64:
        tensor_to_check_dtype = np.complex64
    elif tensor_to_check_dtype == core.VarDesc.VarType.COMPLEX128:
        tensor_tp_check_dtype = np.complex128
157
    else:
158 159 160
        raise ValueError("Not supported data type " +
                         str(tensor_to_check_dtype) + ", tensor name : " +
                         str(input_to_check))
161

C
chengduo 已提交
162 163 164 165
    def get_output():
        sum = []
        op.run(scope, place)
        for output_name in output_names:
166
            output_numpy = np.array(scope.find_var(output_name).get_tensor())
Y
Yiqun Liu 已提交
167 168 169
            # numpy.dtype does not have bfloat16, thus we use numpy.uint16 to
            # store bfloat16 data, and need to be converted to float to check
            # the floating precision.
170 171 172
            if tensor_to_check._dtype() == core.VarDesc.VarType.BF16:
                output_numpy = convert_uint16_to_float(output_numpy)
            sum.append(output_numpy.astype(tensor_to_check_dtype).mean())
C
chengduo 已提交
173 174
        return tensor_to_check_dtype(np.array(sum).sum() / len(output_names))

175 176 177
    gradient_flat = np.zeros(shape=(tensor_size, ), dtype=tensor_to_check_dtype)

    def __get_elem__(tensor, i):
D
dzhwinter 已提交
178 179 180 181
        if tensor_to_check_dtype == np.float16:
            numpy_tensor = np.array(tensor).astype(np.float16)
            numpy_tensor = numpy_tensor.flatten()
            return numpy_tensor[i]
182 183 184
        elif tensor_to_check._dtype() == core.VarDesc.VarType.BF16:
            numpy_tensor = np.array(tensor).astype(np.uint16)
            numpy_tensor = numpy_tensor.flatten()
185 186 187 188
            return struct.unpack(
                '<f',
                struct.pack('<I',
                            np.uint32(numpy_tensor[i]) << np.uint32(16)))[0]
D
dzhwinter 已提交
189
        elif tensor_to_check_dtype == np.float32:
Y
yuyang18 已提交
190
            return tensor._get_float_element(i)
191
        elif tensor_to_check_dtype == np.float64:
Y
yuyang18 已提交
192
            return tensor._get_double_element(i)
193 194 195
        else:
            raise TypeError("Unsupported test data type %s." %
                            tensor_to_check_dtype)
196 197

    def __set_elem__(tensor, i, e):
D
dzhwinter 已提交
198 199 200 201 202
        if tensor_to_check_dtype == np.float16:
            numpy_tensor = np.array(tensor).astype(np.float16)
            shape = numpy_tensor.shape
            numpy_tensor = numpy_tensor.flatten()
            numpy_tensor[i] = e
203
            numpy_tensor = numpy_tensor.reshape(shape)
D
dzhwinter 已提交
204
            tensor.set(numpy_tensor, place)
205 206 207 208 209 210 211
        elif tensor_to_check._dtype() == core.VarDesc.VarType.BF16:
            numpy_tensor = np.array(tensor).astype(np.uint16)
            shape = numpy_tensor.shape
            numpy_tensor = numpy_tensor.flatten()
            numpy_tensor[i] = np.uint16(copy_bits_from_float_to_uint16(e))
            numpy_tensor = numpy_tensor.reshape(shape)
            tensor.set(numpy_tensor, place)
D
dzhwinter 已提交
212
        elif tensor_to_check_dtype == np.float32:
Y
yuyang18 已提交
213
            tensor._set_float_element(i, e)
214
        elif tensor_to_check_dtype == np.float64:
Y
yuyang18 已提交
215
            tensor._set_double_element(i, e)
216 217 218
        else:
            raise TypeError("Unsupported test data type %s." %
                            tensor_to_check_dtype)
219

220 221
    # we only compute gradient of one element each time.
    # we use a for loop to compute the gradient of every element.
M
minqiyang 已提交
222
    for i in six.moves.xrange(tensor_size):
223
        if in_place:
224
            set_input(scope, op, inputs, place)
225 226

        # get one input element throw it's index i.
227
        origin = __get_elem__(tensor_to_check, i)
228 229
        # add delta to it, run op and then get the sum of the result tensor.
        x_pos = origin + delta
230
        __set_elem__(tensor_to_check, i, x_pos)
231 232 233
        y_pos = get_output()

        if in_place:
234
            set_input(scope, op, inputs, place)
235 236

        x_neg = origin - delta
237
        __set_elem__(tensor_to_check, i, x_neg)
238 239
        y_neg = get_output()

240
        __set_elem__(tensor_to_check, i, origin)
241 242
        gradient_flat[i] = (y_pos - y_neg) / delta / 2

Y
yuyang18 已提交
243
    return gradient_flat.reshape(tensor_to_check.shape())
244 245


246 247
def skip_check_grad_ci(reason=None):
    """Decorator to skip check_grad CI.
C
cc 已提交
248

249
       Check_grad is required for Op test cases. However, there are some special
C
cc 已提交
250
       cases that do not need to do check_grad. This decorator is used to skip the
251
       check_grad of the above cases.
C
cc 已提交
252 253

       Note: the execution of unit test will not be skipped. It just avoids check_grad
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
       checking in tearDownClass method by setting a `no_need_check_grad` flag.

       Example:
           @skip_check_grad_ci(reason="For inference, check_grad is not required.")
           class TestInference(OpTest):
    """
    if not isinstance(reason, str):
        raise AssertionError("The reason for skipping check_grad is required.")

    def wrapper(cls):
        cls.no_need_check_grad = True
        return cls

    return wrapper


270 271 272 273 274 275 276 277 278 279 280 281
def skip_check_inplace_ci(reason=None):
    if not isinstance(reason, str):
        raise AssertionError(
            "The reason for skipping check_inplace is required.")

    def wrapper(cls):
        cls.no_need_check_inplace = True
        return cls

    return wrapper


282 283 284 285
def copy_bits_from_float_to_uint16(f):
    return struct.unpack('<I', struct.pack('<f', f))[0] >> 16


286 287 288 289
def convert_float_to_uint16(float_list, data_format="NCHW"):
    if data_format == "NHWC":
        float_list = np.transpose(float_list, [0, 3, 1, 2])

290 291 292
    new_output = []
    for x in np.nditer(float_list):
        new_output.append(np.uint16(copy_bits_from_float_to_uint16(x)))
293
    new_output = np.reshape(new_output, float_list.shape).view(np.uint16)
294

295 296 297
    if data_format == "NHWC":
        new_output = np.transpose(new_output, [0, 2, 3, 1])
    return new_output
298 299


300 301
def convert_uint16_to_float(in_list):
    in_list = np.asarray(in_list)
302 303 304 305
    out = np.vectorize(lambda x: struct.unpack(
        '<f', struct.pack('<I',
                          np.uint32(x) << np.uint32(16)))[0],
                       otypes=[np.float32])(in_list.flat)
306
    return np.reshape(out, in_list.shape)
307 308


309
class OpTest(unittest.TestCase):
310

311 312 313 314 315
    @classmethod
    def setUpClass(cls):
        '''Fix random seeds to remove randomness from tests'''
        cls._np_rand_state = np.random.get_state()
        cls._py_rand_state = random.getstate()
316
        cls.call_once = False
317
        cls.dtype = None
318
        cls.outputs = {}
319
        cls.input_shape_is_large = True
320 321 322 323

        np.random.seed(123)
        random.seed(124)

324 325 326 327
        if paddle.is_compiled_with_npu():
            cls._use_system_allocator = _set_use_system_allocator(False)
        else:
            cls._use_system_allocator = _set_use_system_allocator(True)
328

329 330
    @classmethod
    def tearDownClass(cls):
Y
yuyang18 已提交
331
        """Restore random seeds"""
332 333 334
        np.random.set_state(cls._np_rand_state)
        random.setstate(cls._py_rand_state)

335 336
        _set_use_system_allocator(cls._use_system_allocator)

337 338 339 340
        def is_empty_grad_op(op_type):
            all_op_kernels = core._get_all_register_op_kernels()
            grad_op = op_type + '_grad'
            if grad_op in all_op_kernels.keys():
J
juncaipeng 已提交
341
                if is_mkldnn_op_test():
342 343 344 345 346 347 348 349
                    grad_op_kernels = all_op_kernels[grad_op]
                    for grad_op_kernel in grad_op_kernels:
                        if 'MKLDNN' in grad_op_kernel:
                            return False
                else:
                    return False
            return True

350 351 352
        def is_xpu_op_test():
            return hasattr(cls, "use_xpu") and cls.use_xpu == True

J
juncaipeng 已提交
353
        def is_mkldnn_op_test():
354
            return hasattr(cls, "use_mkldnn") and cls.use_mkldnn == True
J
juncaipeng 已提交
355

356 357 358
        def is_rocm_op_test():
            return core.is_compiled_with_rocm()

359 360 361
        def is_npu_op_test():
            return hasattr(cls, "use_npu") and cls.use_npu == True

362 363 364
        def is_mlu_op_test():
            return hasattr(cls, "use_mlu") and cls.use_mlu == True

365 366 367 368
        def is_custom_device_op_test():
            return hasattr(
                cls, "use_custom_device") and cls.use_custom_device == True

369 370
        if not hasattr(cls, "op_type"):
            raise AssertionError(
371 372
                "This test do not have op_type in class attrs, "
                "please set self.__class__.op_type=the_real_op_type manually.")
373

J
juncaipeng 已提交
374 375
        # case in NO_FP64_CHECK_GRAD_CASES and op in NO_FP64_CHECK_GRAD_OP_LIST should be fixed
        if not hasattr(cls, "no_need_check_grad") \
376
            and not is_empty_grad_op(cls.op_type):
J
juncaipeng 已提交
377
            if cls.dtype is None or \
378 379
                (cls.dtype == np.float16 \
                    and cls.op_type not in op_accuracy_white_list.NO_FP16_CHECK_GRAD_OP_LIST \
J
juncaipeng 已提交
380 381 382 383
                    and not hasattr(cls, "exist_check_grad")):
                raise AssertionError("This test of %s op needs check_grad." %
                                     cls.op_type)

384
            # check for op test with fp64 precision, but not check mkldnn op test for now
J
juncaipeng 已提交
385 386
            if cls.dtype in [np.float32, np.float64] \
                and cls.op_type not in op_accuracy_white_list.NO_FP64_CHECK_GRAD_OP_LIST \
387
                and not hasattr(cls, 'exist_fp64_check_grad') \
388
                and not is_xpu_op_test() \
389
                and not is_mkldnn_op_test() \
390
                and not is_rocm_op_test() \
391
                and not is_npu_op_test() \
392 393
                and not is_mlu_op_test() \
                and not is_custom_device_op_test():
J
juncaipeng 已提交
394 395 396 397
                raise AssertionError(
                    "This test of %s op needs check_grad with fp64 precision." %
                    cls.op_type)

398
            if not cls.input_shape_is_large \
399 400 401 402
                and cls.op_type not in check_shape_white_list.NEED_TO_FIX_OP_LIST:
                raise AssertionError(
                    "Input's shape should be large than or equal to 100 for " +
                    cls.op_type + " Op.")
403

404 405 406 407 408
    def try_call_once(self, data_type):
        if not self.call_once:
            self.call_once = True
            self.dtype = data_type

409
    def is_bfloat16_op(self):
Y
Yiqun Liu 已提交
410 411
        # self.dtype is the dtype of inputs, and is set in infer_dtype_from_inputs_outputs.
        # Make sure this function is called after calling infer_dtype_from_inputs_outputs.
412 413 414 415 416 417
        return self.dtype == np.uint16 or (hasattr(
            self, 'output_dtype') and self.output_dtype == np.uint16) or (
                hasattr(self, 'mkldnn_data_type')
                and getattr(self, 'mkldnn_data_type') == "bfloat16") or (
                    hasattr(self, 'attrs') and 'mkldnn_data_type' in self.attrs
                    and self.attrs['mkldnn_data_type'] == 'bfloat16')
Y
Yiqun Liu 已提交
418 419 420

    def is_mkldnn_op(self):
        return (hasattr(self, "use_mkldnn") and self.use_mkldnn == True) or (
421 422
            hasattr(self, "attrs") and "use_mkldnn" in self.attrs
            and self.attrs["use_mkldnn"] == True)
Y
Yiqun Liu 已提交
423 424

    def is_xpu_op(self):
425 426 427 428
        return (hasattr(self, "use_xpu")
                and self.use_xpu == True) or (hasattr(self, "attrs")
                                              and "use_xpu" in self.attrs
                                              and self.attrs["use_xpu"] == True)
429

430
    # set the self.output_dtype .
431
    def infer_dtype_from_inputs_outputs(self, inputs, outputs):
432

J
juncaipeng 已提交
433 434 435 436
        def is_np_data(input):
            return isinstance(input, (np.ndarray, np.generic))

        def infer_dtype(numpy_dict, dtype_set):
437 438 439
            assert isinstance(
                numpy_dict,
                dict), "self.inputs, self.outputs must be numpy_dict"
J
juncaipeng 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
            # the inputs are as follows:
            # case 1: inputs = {'X': x}
            # case 2: inputs = {'X': (x, x_lod)}
            # case 3: inputs = {"X": [("x0", x0), ("x1", x1), ("x2", x2)]}
            # case 4: inputs = {'X': [("x1", (x1, [x1_lod1])), ("x2", (x2, [x2_.lod2]))]}
            # TODO(juncaipeng) infer dtype from inputs maybe obtain wrong type.
            for _, var_value in six.iteritems(numpy_dict):
                if is_np_data(var_value):  # case 1
                    dtype_set.add(var_value.dtype)
                elif isinstance(var_value, (list, tuple)):  # case 2, 3, 4
                    for sub_val_value in var_value:
                        if is_np_data(sub_val_value):  # case 2
                            dtype_set.add(sub_val_value.dtype)
                        elif len(sub_val_value) > 1 and is_np_data(
                                sub_val_value[1]):  # case 3
                            dtype_set.add(sub_val_value[1].dtype)
                        elif len(sub_val_value) > 1 and isinstance(sub_val_value[1], (list, tuple)) \
                            and is_np_data(sub_val_value[1][0]): # case 4
                            dtype_set.add(sub_val_value[1][0].dtype)

        # infer dtype from inputs, and dtype means the precision of the test
        # collect dtype of all inputs
Y
Yiqun Liu 已提交
462 463
        input_dtype_set = set()
        infer_dtype(inputs, input_dtype_set)
J
juncaipeng 已提交
464
        dtype_list = [
465 466 467 468 469 470 471 472 473
            np.dtype(np.float64),
            np.dtype(np.float32),
            np.dtype(np.float16),
            np.dtype(np.int64),
            np.dtype(np.int32),
            np.dtype(np.uint16),
            np.dtype(np.int16),
            np.dtype(np.int8),
            np.dtype(np.uint8),
474
            np.dtype(np.bool_)
J
juncaipeng 已提交
475 476 477
        ]
        # check the dtype in dtype_list in order, select the first dtype that in dtype_set
        for dtype in dtype_list:
Y
Yiqun Liu 已提交
478
            if dtype in input_dtype_set:
J
juncaipeng 已提交
479 480
                self.dtype = dtype
                break
Y
Yiqun Liu 已提交
481
        # save input dtype in class attr
482
        self.__class__.dtype = self.dtype
483

Y
Yiqun Liu 已提交
484 485 486 487 488 489 490 491
        # infer dtype of outputs
        output_dtype_set = set()
        infer_dtype(outputs, output_dtype_set)
        for dtype in dtype_list:
            if dtype in output_dtype_set:
                self.output_dtype = dtype
                break

Y
Yang Yang(Tony) 已提交
492 493 494 495 496 497
    def feed_var(self, input_vars, place):
        feed_map = {}
        for var_name in input_vars:
            if isinstance(input_vars[var_name], list):
                for name, np_value in self.inputs[var_name]:
                    tensor = core.LoDTensor()
498
                    if isinstance(np_value, tuple):
499
                        tensor.set(np_value[0], place)
500
                        tensor.set_recursive_sequence_lengths(np_value[1])
501
                    else:
502
                        tensor.set(np_value, place)
Y
Yang Yang(Tony) 已提交
503 504 505 506
                    feed_map[name] = tensor
            else:
                tensor = core.LoDTensor()
                if isinstance(self.inputs[var_name], tuple):
507
                    tensor.set(self.inputs[var_name][0], place)
508 509
                    tensor.set_recursive_sequence_lengths(
                        self.inputs[var_name][1])
Y
Yang Yang(Tony) 已提交
510
                else:
511
                    tensor.set(self.inputs[var_name], place)
Y
Yang Yang(Tony) 已提交
512 513 514
                feed_map[var_name] = tensor
        return feed_map

515
    def _append_ops(self, block):
J
juncaipeng 已提交
516
        self.__class__.op_type = self.op_type  # for ci check, please not delete it for now
Y
Yiqun Liu 已提交
517
        if self.is_mkldnn_op():
518
            self.__class__.use_mkldnn = True
C
cc 已提交
519

Y
Yiqun Liu 已提交
520
        if self.is_xpu_op():
521 522
            self.__class__.use_xpu = True

Y
Yang Yang(Tony) 已提交
523
        op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)
524
        "infer datatype from inputs and outputs for this test case"
525 526 527 528 529 530
        if self.is_bfloat16_op():
            self.dtype = np.uint16
            self.__class__.dtype = self.dtype
            self.output_dtype = np.uint16
        else:
            self.infer_dtype_from_inputs_outputs(self.inputs, self.outputs)
531 532 533 534
        inputs = append_input_output(block, op_proto, self.inputs, True,
                                     self.dtype)
        outputs = append_input_output(block, op_proto, self.outputs, False,
                                      self.dtype)
P
phlrain 已提交
535 536 537

        if hasattr(self, "cache_name_list"):
            for name in self.cache_name_list:
538 539 540 541
                inputs[name] = block.create_var(name=name,
                                                persistable=True,
                                                type=core.VarDesc.VarType.RAW,
                                                stop_gradient=True)
P
phlrain 已提交
542

Y
Yang Yang(Tony) 已提交
543 544 545 546
        op = block.append_op(
            type=self.op_type,
            inputs=inputs,
            outputs=outputs,
547
            attrs=copy(self.attrs) if hasattr(self, "attrs") else dict())
C
cc 已提交
548
        # infer variable type and infer shape in compile-time
Q
QI JUN 已提交
549 550
        op.desc.infer_var_type(block.desc)
        op.desc.infer_shape(block.desc)
Y
Yang Yang(Tony) 已提交
551

552 553
        return op

554 555
    def _get_io_vars(self, block, numpy_inputs):
        inputs = {}
M
minqiyang 已提交
556
        for name, value in six.iteritems(numpy_inputs):
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
            if isinstance(value, list):
                var_list = [
                    block.var(sub_name) for sub_name, sub_value in value
                ]
                inputs[name] = var_list
            else:
                inputs[name] = block.var(name)
        return inputs

    def _get_inputs(self, block):
        return self._get_io_vars(block, self.inputs)

    def _get_outputs(self, block):
        return self._get_io_vars(block, self.outputs)

    def calc_output(self, place):
        outs, _ = self._calc_output(place)
        return outs

M
minqiyang 已提交
576 577 578 579
    def _create_var_from_numpy(self, value):
        if isinstance(value, tuple):
            data = value[0]
            lod = value[1]
L
lujun 已提交
580
            v = fluid.dygraph.base.to_variable(value=data)
581
            v.value().get_tensor().set_recursive_sequence_lengths(lod)
M
minqiyang 已提交
582 583
            return v
        else:
L
lujun 已提交
584
            return fluid.dygraph.base.to_variable(value)
M
minqiyang 已提交
585

586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
    def get_sequence_batch_size_1_input(self, lod=None, shape=None):
        """Get LoD input data whose batch size is 1.
        All sequence related OP unittests should call this function to contain the case of batch size = 1.
        Args:
            lod (list[list of int], optional): Length-based LoD, length of lod[0] should be 1. Default: [[13]].
            shape (list, optional): Shape of input, shape[0] should be equals to lod[0][0]. Default: [13, 23].
        Returns:
            tuple (ndarray, lod) : LoD input data whose batch size is 1.
        """
        if lod is None:
            lod = [[13]]
        if shape is None:
            shape = [13, 23]
        assert len(lod[0]) == 1
        assert lod[0][0] == shape[0]
        x = np.random.uniform(0.1, 1, shape).astype('float32')
        return (x, lod)

604 605 606 607 608 609 610 611
    def lod_has_single_zero(self, lod):
        for i in range(len(lod) - 2):
            if lod[i] != 0 and lod[i + 1] == 0 and lod[i + 2] != 0:
                return True
        return False

    def lod_has_continuous_zero(self, lod):
        for i in range(len(lod) - 3):
612 613 614
            if lod[i] != 0 and lod[i +
                                   1] == 0 and lod[i +
                                                   2] == 0 and lod[i + 3] != 0:
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
                return True
        return False

    def get_sequence_instance_size_0_input(self, lod=None, shape=None):
        """Get LoD input data whose instance size is 0.
        All sequence related OP unittests should call this function to contain the case of instance size is 0.
        Args:
            lod (list[list of int], optional): Length-based LoD, lod[0]'s size must at least eight, lod[0] must at least two zeros at the beginning and at least two zeros at the end, the middle position of lod[0] contains a single zero and multiple zero. Default: [[0, 0, 4, 0, 3, 0, 0, 5, 0, 0]].
            shape (list, optional): Shape of input, shape[0] should be equals to lod[0][0]. Default: [13, 23].
        Returns:
            tuple (ndarray, lod): LoD input data whose instance size is 0.
        """
        if lod is None:
            lod = [[0, 0, 4, 0, 3, 0, 0, 5, 0, 0]]
        if shape is None:
            shape = [12, 10]
        assert len(lod[0]) >= 8
        assert lod[0][0] == 0 and lod[0][1] == 0 and lod[0][-1] == 0 and lod[0][
            -2] == 0
        assert self.lod_has_single_zero(lod[0]) is True
        assert self.lod_has_continuous_zero(lod[0]) is True
        assert sum(lod[0]) == shape[0]

        x = np.random.uniform(0.1, 1, shape).astype('float32')
        return (x, lod)

641 642
    def append_input_output_for_dygraph(self, op_proto, np_list, is_input,
                                        if_return_inputs_grad_dict, block):
643

644 645 646 647 648 649 650 651 652 653 654
        def create_var(np_value, name, is_input, if_return_inputs_grad_dict):
            np_value_temp = np_value
            has_lod = False
            lod_temp = None
            if isinstance(np_value, tuple):
                np_value_temp = np_value[0]
                has_lod = True
                lod_temp = np_value[1]

            if is_input:
                v = self._create_var_from_numpy(np_value_temp)
655

656 657
                if if_return_inputs_grad_dict:
                    v.stop_gradient = False
J
Jiabin Yang 已提交
658
                    if not _in_legacy_dygraph():
659 660
                        v.retain_grads()

661
                if has_lod:
662
                    v.value().get_tensor().set_recursive_sequence_lengths(
663 664
                        lod_temp)
            else:
665 666 667 668 669
                v = block.create_var(name=name,
                                     dtype=np_value_temp.dtype,
                                     type=core.VarDesc.VarType.LOD_TENSOR,
                                     persistable=False,
                                     stop_gradient=False)
670 671 672 673 674 675 676 677 678 679 680 681 682
            return v

        # prepare variable for input or output
        var_dict = defaultdict(list)
        if if_return_inputs_grad_dict:
            inputs_grad_dict = defaultdict()
        proto_list = op_proto.inputs if is_input else op_proto.outputs
        for var_proto in proto_list:
            name = var_proto.name
            if (name not in np_list) and var_proto.dispensable:
                continue
            if name not in np_list:
                assert var_proto.intermediate, "{} not found".format(name)
683 684
                v = block.create_var(dtype='float32',
                                     type=core.VarDesc.VarType.LOD_TENSOR)
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
                var_dict[name].append(v)
                if if_return_inputs_grad_dict:
                    inputs_grad_dict[name] = v
                continue
            if var_proto.duplicable:
                assert isinstance(
                    np_list[name],
                    list), "Duplicable {} should be set as list".format(name)
                var_list = []
                slot_name = name
                for (name, np_value) in np_list[name]:
                    v = create_var(np_value, name, is_input,
                                   if_return_inputs_grad_dict)
                    var_list.append(v)
                    if if_return_inputs_grad_dict:
                        inputs_grad_dict[name] = v
                var_dict[slot_name] = var_list
            else:
                nplist_value_temp = None
                name_temp = None
                if isinstance(np_list[name], list):
                    nplist_value_temp = np_list[name][0]
                    name_temp = name
                else:
                    nplist_value_temp = np_list[name]
                    name_temp = unique_name.generate("%s_out" % (name))
                v = create_var(nplist_value_temp, name_temp, is_input,
                               if_return_inputs_grad_dict)
                var_dict[name].append(v)
                if if_return_inputs_grad_dict:
                    inputs_grad_dict[name] = v

        if if_return_inputs_grad_dict:
            return var_dict, inputs_grad_dict
        else:
            return var_dict

722 723 724 725 726 727 728 729 730 731
    def _check_api_outs_by_dygraph_outs(self, api_outs, dygraph_outs, place):
        """ for quick verify, here we take a simplest strategy:
                1. we only check variable in api_outs.
                2. we simply check the numpy (tensor) .
                3. we set atol and rtol as 1e-5, because they are unrelated to dtype.
        """
        for name in api_outs:
            np_api = np.array(api_outs[name])
            np_dyg = np.array(dygraph_outs[name])
            self.assertTrue(
732 733 734 735
                np.allclose(np_api, np_dyg, equal_nan=False),
                "Output (" + name + ") has diff at " + str(place) +
                "\nExpect " + str(np_dyg) + "\n" + "But Got" + str(np_api) +
                " in class " + self.__class__.__name__)
736

737 738 739 740
    def _calc_python_api_output(self, place, egr_inps=None, egr_oups=None):
        """ set egr_inps and egr_oups = None if you want to create it by yourself.
        """

741
        def prepare_python_api_arguments(api, op_proto_ins, op_proto_attrs,
742 743
                                         kernel_sig):
            """ map from `op proto inputs and attrs` to `api input list and api attrs dict`
Z
zyfncg 已提交
744 745
                
                NOTE: the op_proto_attrs and op_proto_ins is a default dict. default value is []
746
            """
747 748 749 750 751 752 753

            class Empty:
                pass

            def is_empty(a):
                return isinstance(a, Empty)

754 755 756 757 758
            def get_default(idx, defaults):
                assert not isinstance(
                    defaults[idx], Empty
                ), "%d-th params of python api don't have default value." % idx
                return defaults[idx]
759 760 761 762

            def to_defaults_list(params, defaults):
                return [defaults[p] for p in params if p in defaults]

763 764 765 766 767 768 769 770 771
            def parse_attri_value(name, op_inputs, op_attrs):
                """ parse true value from inputs and attrs, if there is no name passed by OpTest, return Empty
                    1. if the name in op_attrs, use the op_attrs[name]
                    2. if the name in op_inputs, convert the op_inputs to [type of default value]
                    3. if the name not in op_attrs ans op_inputs, return Empty. (this will use the default value from python api)
                """
                if name in op_proto_attrs:
                    return op_proto_attrs[name]
                elif name in op_inputs:
X
xiongkun 已提交
772 773
                    if len(op_inputs[name]) == 1:
                        # why don't use numpy().item() : if the Tensor is float64, we will change it to python.float32, where we loss accuracy: [allclose_op]
774 775 776
                        # why we reconstruct a tensor: because we want the tensor in cpu.
                        return paddle.to_tensor(op_inputs[name][0].numpy(),
                                                place='cpu')
X
xiongkun 已提交
777 778 779
                    else:
                        # if this is a list (test_unsqueeze2_op): we just pass it into the python api.
                        return op_inputs[name]
780 781 782
                else:
                    return Empty()

783 784 785
            # NOTE(xiongkun): the logic of constructing parameters:
            # for example:
            #    python api: cumprod(x, dim, dtype=None, name=None)
786 787 788 789 790 791 792
            #    kernel sig: [["x"], ["dim"], ["out"]]"
            #
            # we will construct a lot of list with the same length : len == len(api_params), here is 4
            #    api_params = ["x", "dim", "dtype", "name"]
            #    api_defaults = [Empty, Empty, None, None]; empty means no defaults.
            #    inputs_and_attrs = ["x", "dim"] , the length may shorter or longer than api_params
            #    input_arguments = [RealValue in self.inputs and self.attrs]
793
            # then ,we will loop for the api_params, construct a result list:
794 795 796 797
            #    if the name in ['name', 'dtype', 'out', 'output'], we will use the default value
            #    else, we will consume a input_arguments. (because the name is not corresponding, so we only use the order)

            api_params, api_defaults = parse_arg_and_kwargs(api)
798
            api_defaults = to_defaults_list(api_params, api_defaults)
799 800 801 802 803
            api_defaults = [
                Empty() for i in range(len(api_params) - len(api_defaults))
            ] + api_defaults
            assert len(api_defaults) == len(
                api_params), "Error happens. contack xiongkun03 to solve."
804
            inputs_sig, attrs_sig, outputs_sig = kernel_sig
805
            inputs_and_attrs = inputs_sig + attrs_sig
Z
zyfncg 已提交
806 807 808
            input_arguments = [
                op_proto_ins.get(name, Empty()) for name in inputs_sig
            ] + [
809
                parse_attri_value(name, op_proto_ins, op_proto_attrs)
810 811 812
                for name in attrs_sig
            ]
            results = []
813 814 815 816 817
            api_ignore_param_list = set(['name', 'dtype', 'out', 'output'])
            idx_of_op_proto_arguments = 0
            for idx, arg_name in enumerate(api_params):
                if arg_name in api_ignore_param_list:
                    results.append(get_default(idx, api_defaults))
818
                else:
819 820 821 822 823 824
                    if (idx_of_op_proto_arguments < len(input_arguments)):
                        tmp = input_arguments[idx_of_op_proto_arguments]
                        idx_of_op_proto_arguments += 1
                    else:
                        tmp = Empty()  # use the default value

825 826 827 828 829
                    if isinstance(tmp, Empty):
                        results.append(get_default(idx, api_defaults))
                    else:
                        results.append(tmp)
            assert len(results) == len(api_params)
830
            return results
831 832

        def construct_output_dict_by_kernel_sig(ret_tuple, output_sig):
X
xiongkun 已提交
833 834
            if hasattr(self, "python_out_sig"):
                output_sig = self.python_out_sig
835 836
            if not isinstance(ret_tuple, (tuple, list)):
                ret_tuple = [ret_tuple]
837 838 839 840 841 842 843
            if len(output_sig) == len(ret_tuple):
                # [assumption]: we assume {"Out": [Tensor]}
                return {a: [b] for a, b in zip(output_sig, ret_tuple)}
            else:
                # [assumption]: return multi-Tensor in a single output. such as paddle.split()
                assert len(
                    output_sig
X
xiongkun 已提交
844
                ) == 1, "Don't support multi-output with multi-tensor output. (May be you can use set `python_out_sig`, see `test_squeeze2_op` as a example.)"
845
                return {output_sig[0]: ret_tuple}
846

847
        def assumption_assert_and_transform(args, inp_num):
848
            """
849
            transform inputs by the following rules:
850 851
                1. [Tensor] -> Tensor
                2. [Tensor, Tensor, ...] -> list of Tensors
Z
zyfncg 已提交
852 853
                3. None -> None
                4. Others: raise Error
854 855

            only support "X" is list of Tensor, currently don't support other structure like dict.
856
            """
Z
zyfncg 已提交
857 858 859
            inp_args = [[inp] if inp is None else inp
                        for inp in args[:inp_num]]  # convert None -> [None]
            for inp in inp_args:
860 861 862
                assert isinstance(
                    inp, list
                ), "currently only support `X` is [Tensor], don't support other structure."
Z
zyfncg 已提交
863 864
            args = [inp[0] if len(inp) == 1 else inp
                    for inp in inp_args] + args[inp_num:]
865
            return args
866

867 868 869 870 871 872 873 874 875 876
        def _get_kernel_signature(eager_tensor_inputs, eager_tensor_outputs,
                                  attrs_outputs):
            try:
                kernel_sig = _dygraph_tracer()._get_kernel_signature(
                    self.op_type, eager_tensor_inputs, eager_tensor_outputs,
                    attrs_outputs)
            except RuntimeError as re:
                """ we think the kernel_sig is missing.
                """
                kernel_sig = None
X
xiongkun 已提交
877 878 879
                print(
                    "[Warning: op_test.py] Kernel Signature is not found for %s, fall back to intermediate state."
                    % self.op_type)
880 881
            return kernel_sig

882
        def cal_python_api(python_api, args, kernel_sig):
883
            inputs_sig, attrs_sig, outputs_sig = kernel_sig
884 885
            args = assumption_assert_and_transform(args, len(inputs_sig))
            ret_tuple = python_api(*args)
886 887 888 889 890 891
            return construct_output_dict_by_kernel_sig(ret_tuple, outputs_sig)

        with fluid.dygraph.base.guard(place=place):
            block = fluid.default_main_program().global_block()
            op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)
            # prepare input variable
892
            eager_tensor_inputs = egr_inps if egr_inps else self.append_input_output_for_dygraph(
893
                op_proto, self.inputs, True, False, block)
894
            # prepare output variable
895
            eager_tensor_outputs = egr_oups if egr_oups else self.append_input_output_for_dygraph(
896 897
                op_proto, self.outputs, False, False, block)

898
            # prepare attributes
899 900 901 902 903 904
            attrs_outputs = {}
            if hasattr(self, "attrs"):
                for attrs_name in self.attrs:
                    if self.attrs[attrs_name] is not None:
                        attrs_outputs[attrs_name] = self.attrs[attrs_name]

905 906 907
            kernel_sig = _get_kernel_signature(eager_tensor_inputs,
                                               eager_tensor_outputs,
                                               attrs_outputs)
908 909
            if not kernel_sig:
                return None
910 911
            assert hasattr(
                self, "python_api"
912
            ), "Detect there is KernelSignature for `%s` op, please set the `self.python_api` if you set check_eager = True" % self.op_type
913 914 915
            args = prepare_python_api_arguments(self.python_api,
                                                eager_tensor_inputs,
                                                attrs_outputs, kernel_sig)
916 917
            """ we directly return the cal_python_api value because the value is already tensor. 
            """
918
            return cal_python_api(self.python_api, args, kernel_sig)
919

L
lujun 已提交
920
    def _calc_dygraph_output(self, place, parallel=False, no_check_set=None):
J
juncaipeng 已提交
921
        self.__class__.op_type = self.op_type  # for ci check, please not delete it for now
L
lujun 已提交
922
        with fluid.dygraph.base.guard(place=place):
M
minqiyang 已提交
923 924
            block = fluid.default_main_program().global_block()

925
            op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)
M
minqiyang 已提交
926

927
            # prepare input variable
928 929
            inputs = self.append_input_output_for_dygraph(
                op_proto, self.inputs, True, False, block)
M
minqiyang 已提交
930
            # prepare output variable
931 932 933
            outputs = self.append_input_output_for_dygraph(
                op_proto, self.outputs, False, False, block)

934
            # prepare attributes
935 936 937 938 939
            attrs_outputs = {}
            if hasattr(self, "attrs"):
                for attrs_name in self.attrs:
                    if self.attrs[attrs_name] is not None:
                        attrs_outputs[attrs_name] = self.attrs[attrs_name]
940

M
minqiyang 已提交
941 942 943 944
            block.append_op(
                type=self.op_type,
                inputs=inputs,
                outputs=outputs,
945
                attrs=attrs_outputs if hasattr(self, "attrs") else None)
M
minqiyang 已提交
946
            return outputs
947

948 949 950 951 952 953
    def _calc_output(self,
                     place,
                     parallel=False,
                     no_check_set=None,
                     loss=None,
                     enable_inplace=None,
954
                     for_inplace_test=None):
955 956
        program = Program()
        block = program.global_block()
957
        op = self._append_ops(block)
958 959 960 961 962

        inputs = self._get_inputs(block)
        outputs = self._get_outputs(block)
        feed_map = self.feed_var(inputs, place)

963
        if for_inplace_test:
C
cc 已提交
964 965
            # Some variables' tensors hold no buffer (tensor's _holder is NULL), like XShape in reshape2 op,
            # and the shapes of those variables contain 0 (eg. Xshape.shape = [0, 2, 5]).
966 967
            # Set persistable for those variables in order to get them from global_scope for inplace grad test directly other than feed them,
            # since feed op calls check_memory_size() which fails when tensor's holder_ is NULL.
968 969
            for out_name in op.output_arg_names:
                var = block.var(out_name)
970 971
                if 0 in var.shape:
                    var.persistable = True
972
        original_program = program
973 974
        if parallel:
            use_cuda = False
975
            if isinstance(place, fluid.CUDAPlace):
976
                use_cuda = True
977 978 979
            compiled_prog = fluid.CompiledProgram(program).with_data_parallel(
                loss_name=loss.name if loss else None, places=place)
            program = compiled_prog
980 981 982 983
        fetch_list = getattr(self, "fetch_list", [])
        # if the fetch_list is customized by user, we use it directly.
        # if not, fill the fetch_list by the user configured outputs in test.
        if len(fetch_list) == 0:
M
minqiyang 已提交
984
            for var_name, var in six.iteritems(outputs):
985 986
                if no_check_set is not None and var_name in no_check_set:
                    continue
Y
Yang Yang(Tony) 已提交
987 988
                if isinstance(var, list):
                    for v in var:
989
                        fetch_list.append(v.name)
Y
Yang Yang(Tony) 已提交
990
                else:
991
                    fetch_list.append(var.name)
992 993 994 995
        # if the fetch_list still empty, fill the fetch_list by the operator output.
        if len(fetch_list) == 0:
            for out_name, out_dup in Operator.get_op_outputs(self.op_type):
                fetch_list.append(str(out_name))
996 997 998 999 1000 1001 1002 1003 1004

        if enable_inplace is not None:
            build_strategy = fluid.BuildStrategy()
            build_strategy.enable_inplace = enable_inplace

            compiled_prog = fluid.CompiledProgram(program).with_data_parallel(
                build_strategy=build_strategy, places=place)
            program = compiled_prog

1005
        executor = Executor(place)
1006 1007 1008 1009
        outs = executor.run(program,
                            feed=feed_map,
                            fetch_list=fetch_list,
                            return_numpy=False)
1010 1011
        self.op = op
        self.program = original_program
1012 1013 1014 1015
        if for_inplace_test:
            return outs, fetch_list, feed_map, original_program, op.desc
        else:
            return outs, fetch_list
Y
Yang Yang(Tony) 已提交
1016

1017 1018 1019 1020 1021 1022 1023 1024 1025
    def _compare_expect_and_actual_outputs(self,
                                           place,
                                           fetch_list,
                                           expect_outs,
                                           actual_outs,
                                           inplace_atol=None):
        """Compare expect outs and actual outs of an tested op.

        Args:
C
cc 已提交
1026
            place (CPUPlace | CUDAPlace): The place where the op runs.
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
            fetch_list (list): The outputs of tested op.
            expect_outs (list): The expect outs of tested op.
            actual_outs (list): The actual outs of tested op.
            inplace_atol (float): The tolerable error, only set when tested op doesn't ensure computational consistency, like group_norm op.

        Returns:
            None.
        """
        # compare expect_outs and actual_outs
        for i, name in enumerate(fetch_list):
C
cc 已提交
1037
            # Note(zhiqiu): inplace_atol should be only set when op doesn't ensure
L
Leo Chen 已提交
1038 1039 1040
            # computational consistency.
            # When inplace_atol is not None, the inplace check uses numpy.allclose
            # to check inplace result instead of numpy.array_equal.
1041 1042
            expect_out = np.array(expect_outs[i])
            actual_out = np.array(actual_outs[i])
1043 1044
            if inplace_atol is not None:
                self.assertTrue(
1045
                    np.allclose(expect_out, actual_out, atol=inplace_atol),
1046 1047
                    "Output (" + name + ") has diff at " + str(place) +
                    " when using and not using inplace" + "\nExpect " +
1048 1049
                    str(expect_out) + "\n" + "But Got" + str(actual_out) +
                    " in class " + self.__class__.__name__)
1050 1051
            else:
                self.assertTrue(
1052
                    np.array_equal(expect_out, actual_out),
1053 1054
                    "Output (" + name + ") has diff at " + str(place) +
                    " when using and not using inplace" + "\nExpect " +
1055 1056
                    str(expect_out) + "\n" + "But Got" + str(actual_out) +
                    " in class " + self.__class__.__name__ + '\n')
1057 1058 1059 1060 1061 1062 1063 1064

    def _construct_grad_program_from_forward(self, fwd_program, grad_op_desc,
                                             op_grad_to_var):
        """Generate grad_program which contains the grad_op.

        Args:
            fwd_program (tuple): The program that contains grad_op_desc's corresponding forward op.
            grad_op_desc (OpDesc): The OpDesc of grad op.
C
cc 已提交
1065
            op_grad_to_var (dict): The relation of variables in grad op and its forward op.
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084

        Returns:
            grad_program (program): The program which contains the grad_op.
        """
        grad_program = Program()
        grad_block = grad_program.global_block()
        new_op_desc = grad_block.desc.append_op()
        new_op_desc.copy_from(grad_op_desc)
        grad_program._sync_with_cpp()

        # Create grad vars based on fwd vars (shape and dtype)
        for arg in grad_op_desc.input_arg_names(
        ) + grad_op_desc.output_arg_names():
            fwd_var_name = op_grad_to_var.get(arg, None)
            if fwd_var_name is None:
                fwd_var_name = arg
            fwd_var = fwd_program.global_block().vars.get(fwd_var_name)
            assert fwd_var is not None, "{} cannot be found".format(
                fwd_var_name)
1085 1086 1087 1088 1089
            grad_var = grad_block.create_var(name=arg,
                                             dtype=fwd_var.dtype,
                                             shape=fwd_var.shape,
                                             type=fwd_var.type,
                                             persistable=False)
1090

C
cc 已提交
1091 1092
            # Some variables' tensors hold no buffer (tensor's _holder is NULL), like XShape in reshape2 op,
            # and the shapes of those variables contain 0 (eg. Xshape.shape = [0, 2, 5]).
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
            # Set persistable for those variables in order to get them from global_scope for inplace grad test directly other than feed them,
            # since feed op calls check_memory_size() which fails when tensor's holder_ is NULL.
            if 0 in grad_var.shape:
                grad_var.persistable = True
        grad_program._sync_with_cpp()
        return grad_program

    def _construct_grad_feed_map_from_forward(self, place, fwd_res,
                                              grad_op_desc, op_grad_to_var):
        """Generate grad_feed_map for grad_program.

        since we don`t really check gradient accuracy, but check the consistency when using and not using inplace,
        we use fwd outs (also inputs sometimes) to construct grad inputs.

        Args:
C
cc 已提交
1108
            place (CPUPlace | CUDAPlace): The place where the op runs.
1109 1110 1111
            fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_inplace_test is True.
                i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc)
            grad_op_desc (OpDesc): The OpDesc of grad op.
C
cc 已提交
1112
            op_grad_to_var (dict): The relation of variables in grad op and its fwd_op.
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143

        Returns:
            grad_feed_map (dict): The feed_map of grad_op.
        """
        fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc = fwd_res
        p = core.Place()
        p.set_place(place)
        grad_feed_map = {}
        for arg in grad_op_desc.input_arg_names():
            if arg in fwd_feed_map.keys():
                grad_feed_map[arg] = fwd_feed_map[arg]._copy(p)
            else:
                fwd_var_name = op_grad_to_var.get(arg, None)
                if fwd_var_name is None:
                    fwd_var_name = arg

                for i, out_name in enumerate(fwd_fetch_list):
                    if out_name == fwd_var_name:
                        # don't feed variables whose tensors hold no buffer (shape contains 0 like shape = [0,2,5] and holder_ is NULL), like XShape in reshape2 op.
                        # get them from global_scope directly since we have set them persistable in fwd execution
                        if 0 in fwd_program.global_block().var(out_name).shape:
                            continue
                        else:
                            grad_feed_map[arg] = fwd_outs[i]._copy(p)
        return grad_feed_map

    def _get_need_run_ops(self, op_desc, fwd_op_desc=None):
        """Postorder traversal of the 'grad' tree to get all ops that need to run during inplace test.
        An op needs to run druing inplace check if,
        (1) it has infer_inplace,
        (2) it has infer_inplace in its grad descendants. (since we need its outputs as to construct its grad's inputs)
C
cc 已提交
1144

1145
        Args:
C
cc 已提交
1146 1147
            op_desc (OpDesc): The op_desc of current op.
            fwd_op_desc (OpDesc): The op_desc of current op's forward op, None if current op has no forward op.
1148
                Eg. relu's fwd_op is None, relu_grad's fwd_op is relu, relu_grad_grad's fwd_op is relu_grad, etc.
C
cc 已提交
1149

1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
        Returns:
            need_run_ops (list[(op_desc, fwd_op_desc)]): The ops that need to run during inplace test.
        """
        need_run_ops = []
        visited_ops = []

        def _dfs_grad_op(op_desc, fwd_op_desc=None):
            visited_ops.append(op_desc.type())
            has_infer_inplace = fluid.core.has_infer_inplace(op_desc.type())
            has_grad_op_maker = fluid.core.has_grad_op_maker(op_desc.type())
            has_infer_inplace_in_grad_descendants = False
            if not has_grad_op_maker:
                has_infer_inplace_in_descendants = False
            else:
C
cc 已提交
1164
                # get grad_op_desc
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
                grad_op_desc_list, op_grad_to_var = core.get_grad_op_desc(
                    op_desc, set(), [])
                if not grad_op_desc_list:
                    has_infer_inplace_in_grad_descendants = False
                else:
                    for i, grad_op_desc in enumerate(grad_op_desc_list):
                        if grad_op_desc.type(
                        ) not in visited_ops and _dfs_grad_op(
                                grad_op_desc, fwd_op_desc=op_desc):
                            has_infer_inplace_in_grad_descendants = True
            if has_infer_inplace or has_infer_inplace_in_grad_descendants:
                need_run_ops.append((op_desc, fwd_op_desc))
                return True
            else:
                return False

        _dfs_grad_op(op_desc, fwd_op_desc=fwd_op_desc)
        return need_run_ops

    def _check_forward_inplace(self,
                               place,
                               no_check_set=None,
                               inplace_atol=None):
1188
        """Check the inplace correctness of given op (self.op_type).
1189
        Run the op twice with same inputs, one enable inplace and another disable, compare their outputs.
C
cc 已提交
1190

1191
        Args:
C
cc 已提交
1192
            place (CPUPlace | CUDAPlace): The place where the op runs.
1193 1194 1195 1196
            no_check_set (list): The names of outputs that needn't check, like XShape of reshape op.
            inplace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_norm op.

        Returns:
C
cc 已提交
1197 1198
            expect_res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given op.
                We return this to construct grad_program and grad_feed_map for grad inplace check.
1199 1200
        """
        # _calc_output() returns in the form tuple(outs, fetch_list, feed_map, program, op_desc) when for_inplace_test=True.
1201 1202 1203 1204 1205 1206 1207 1208
        expect_res = self._calc_output(place,
                                       no_check_set=no_check_set,
                                       enable_inplace=False,
                                       for_inplace_test=True)
        actual_res = self._calc_output(place,
                                       no_check_set=no_check_set,
                                       enable_inplace=True,
                                       for_inplace_test=True)
1209
        # compare expect_outs and actual_outs
1210 1211 1212 1213 1214
        self._compare_expect_and_actual_outputs(place,
                                                expect_res[1],
                                                expect_res[0],
                                                actual_res[0],
                                                inplace_atol=inplace_atol)
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
        return expect_res

    def _calc_grad_output(self,
                          place,
                          fwd_res,
                          grad_op_desc,
                          enable_inplace=None):
        """Calculate grad_output for given grad_op_desc.

        since we don`t really check gradient accuracy, but check the consistency when using and not using inplace,
        we use fwd outs (also inputs sometimes) to construct grad inputs.

        Args:
C
cc 已提交
1228
            place (CPUPlace | CUDAPlace): The place where the op runs.
1229 1230 1231 1232 1233 1234 1235 1236 1237
            fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_inplace_test is True.
                i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc).
            grad_op_desc (OpDesc): The OpDesc of grad op.
            enable_inplace (bool): Enable inplace or not.

        Returns:
            res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given grad_op_desc.
        """
        fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc = fwd_res
1238 1239
        grad_op_desc_list, op_grad_to_var = core.get_grad_op_desc(
            fwd_op_desc, set(), [])
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
        grad_program = self._construct_grad_program_from_forward(
            fwd_program, grad_op_desc, op_grad_to_var)
        grad_feed_map = self._construct_grad_feed_map_from_forward(
            place, fwd_res, grad_op_desc, op_grad_to_var)
        grad_fetch_list = grad_op_desc.output_arg_names()
        exe = Executor(place)
        program = grad_program
        if enable_inplace is not None:
            build_strategy = fluid.BuildStrategy()
            build_strategy.enable_inplace = enable_inplace
            compiled_program = fluid.CompiledProgram(
1251 1252 1253
                grad_program).with_data_parallel(loss_name="",
                                                 build_strategy=build_strategy,
                                                 places=place)
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
            program = compiled_program
        outs = exe.run(program,
                       feed=grad_feed_map,
                       fetch_list=grad_fetch_list,
                       return_numpy=False)
        return outs, grad_fetch_list, grad_feed_map, grad_program, grad_op_desc

    def _check_grad_inplace(self,
                            place,
                            fwd_res,
                            grad_op_desc,
                            inplace_atol=None):
1266
        """Check the inplace correctness of given grad_op_desc.
1267 1268 1269 1270 1271 1272

        Run the grad op twice with same inputs, one enable inplace and another disable, compare their outputs.
        It works like _check_forward_inplace, but the way to construct program and feed_map differs.
        So we define a new function for grad, grad_grad, etc.

        Args:
C
cc 已提交
1273
            place (CPUPlace | CUDAPlace): The place where the op runs.
1274 1275 1276 1277 1278 1279
            fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_inplace_test is True.
                i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc).
            grad_op_desc (OpDesc): The OpDesc of grad op.
            inplace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_norm op.

        Returns:
C
cc 已提交
1280 1281
            expect_res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given op.
                We return this to construct grad_program and grad_feed_map for grad inplace check.
1282
        """
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
        expect_res = self._calc_grad_output(place,
                                            fwd_res,
                                            grad_op_desc,
                                            enable_inplace=False)
        actual_res = self._calc_grad_output(place,
                                            fwd_res,
                                            grad_op_desc,
                                            enable_inplace=True)
        self._compare_expect_and_actual_outputs(place,
                                                expect_res[1],
                                                expect_res[0],
                                                actual_res[0],
                                                inplace_atol=inplace_atol)
1296
        return expect_res
1297

1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
    def check_inplace_output_with_place(self,
                                        place,
                                        no_check_set=None,
                                        inplace_atol=None):
        """Chech the inplace correctness of given op, its grad op, its grad_grad op, etc.

        (1) Get all ops need to run. (see conditions in _get_need_run_ops())
        (2) Run op in need_run_ops, and do inplace check if it has infer_inplace.

        Args:
C
cc 已提交
1308
            place (CPUPlace | CUDAPlace): The place where the op runs.
1309 1310 1311 1312 1313 1314
            no_check_set (list): The names of outputs that needn't check, like XShape of reshape op.
            inplace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_norm op.

        Returns:
            None
        """
1315 1316 1317
        if getattr(self, "no_need_check_inplace", False):
            return

1318 1319 1320
        has_infer_inplace = fluid.core.has_infer_inplace(self.op_type)
        has_grad_op_maker = fluid.core.has_grad_op_maker(self.op_type)

1321 1322 1323
        fwd_res = self._calc_output(place,
                                    no_check_set=no_check_set,
                                    for_inplace_test=True)
1324 1325 1326 1327
        op_desc = fwd_res[4]
        need_run_ops = self._get_need_run_ops(op_desc)

        res = {}
1328 1329
        if hasattr(self, 'attrs') and bool(self.attrs.get('use_xpu', False)):
            return
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
        for op_desc, father_op_desc in reversed(need_run_ops):
            # The first one is the forward op
            has_infer_inplace = fluid.core.has_infer_inplace(op_desc.type())
            if op_desc.type() == self.op_type:
                if has_infer_inplace:
                    res[op_desc] = self._check_forward_inplace(
                        place,
                        no_check_set=no_check_set,
                        inplace_atol=inplace_atol)
                else:
1340 1341 1342
                    res[op_desc] = self._calc_output(place,
                                                     no_check_set=no_check_set,
                                                     for_inplace_test=True)
1343
            else:
1344 1345
                # TODO(zhiqiu): enhance inplace_grad test for ops (sum and activation) using mkldnn
                # skip op that use_mkldnn currently
1346
                flags_use_mkldnn = fluid.core.globals()["FLAGS_use_mkldnn"]
1347 1348
                attrs_use_mkldnn = hasattr(self, 'attrs') and bool(
                    self.attrs.get('use_mkldnn', False))
1349 1350 1351 1352 1353 1354 1355 1356 1357
                if flags_use_mkldnn or attrs_use_mkldnn:
                    warnings.warn(
                        "check inplace_grad for ops using mkldnn is not supported"
                    )
                    continue
                if has_infer_inplace:
                    fwd_res = res[father_op_desc]
                    res[op_desc] = self._check_grad_inplace(
                        place, fwd_res, op_desc, inplace_atol=inplace_atol)
1358
                else:
1359 1360
                    res[op_desc] = self._calc_grad_output(
                        place, fwd_res, op_desc)
1361

1362 1363
    def check_output_with_place(self,
                                place,
1364
                                atol=0,
1365
                                no_check_set=None,
M
minqiyang 已提交
1366
                                equal_nan=False,
1367
                                check_dygraph=True,
1368 1369
                                inplace_atol=None,
                                check_eager=False):
1370

1371 1372 1373 1374 1375 1376 1377 1378
        def find_imperative_actual(target_name, dygraph_outs, place):
            for name in dygraph_outs:
                if name == target_name:
                    return dygraph_outs[name][0]
                var_list = dygraph_outs[name]
                for i, var in enumerate(var_list):
                    if var.name == target_name:
                        return dygraph_outs[name][i]
1379 1380 1381
            self.assertTrue(
                False, "Found failed {} {}".format(dygraph_outs.keys(),
                                                   target_name))
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405

        def find_actual(target_name, fetch_list):
            found = [
                i for i, var_name in enumerate(fetch_list)
                if var_name == target_name
            ]
            self.assertTrue(
                len(found) == 1, "Found {} {}".format(len(found), target_name))
            return found[0]

        class Checker(object):
            """ base class for check with self.outputs.
                currently don't support check between checkers.
            """

            def __init__(self, op_test, expect_dict):
                """ expect_dict is the self.outputs
                    support : {str: [numpy]} and {str: [(str, numpy), (str, numpy)]}
                """
                self.expects = expect_dict
                self.checker_name = "checker"
                self.op_test = op_test  # stop the op_test object.
                self.op_type = op_test.op_type

1406 1407 1408
            def init(self):
                pass

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
            def convert_uint16_to_float(self, actual_np, expect_np):
                raise NotImplementedError("base class, not implement!")

            def calculate_output(self):
                """
                judge whether convert current output and expect to uint16.
                return True | False
                """
                pass

            def _is_skip_name(self, name):
                if name not in self.expects:
                    return True
                if no_check_set is not None and name in no_check_set:
                    return True
                return False

            def find_actual_value(self, name):
                """ return: (actual_tensor(var_base), actual_numpy)
                """
                raise NotImplementedError("base class, not implement!")

            def _compare_numpy(self, name, actual_np, expect_np):
                self.op_test.assertTrue(
                    np.allclose(
                        actual_np,
                        expect_np,
                        atol=atol,
                        rtol=self.rtol if hasattr(self, 'rtol') else 1e-5,
1438 1439
                        equal_nan=equal_nan), "Output (" + name +
                    ") has diff at " + str(place) + " in " + self.checker_name)
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454

            def _compare_list(self, name, actual, expect):
                """ if expect is a tuple, we need to compare list.
                """
                raise NotImplementedError("base class, not implement!")

            def compare_single_output_with_expect(self, name, expect):
                actual, actual_np = self.find_actual_value(name)
                expect_np = expect[0] \
                    if isinstance(expect, tuple) else expect
                actual_np, expect_np = self.convert_uint16_to_float_ifneed(
                    actual_np, expect_np)
                # NOTE(zhiqiu): np.allclose([], [1.]) returns True
                # see details: https://stackoverflow.com/questions/38331703/why-does-numpys-broadcasting-sometimes-allow-comparing-arrays-of-different-leng
                if expect_np.size == 0:
1455
                    self.op_test.assertTrue(actual_np.size == 0)  # }}}
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
                self._compare_numpy(name, actual_np, expect_np)
                if isinstance(expect, tuple):
                    self._compare_list(name, actual, expect)

            def compare_outputs_with_expects(self):
                for out_name, out_dup in Operator.get_op_outputs(self.op_type):
                    if self._is_skip_name(out_name): continue
                    if out_dup:
                        # if self.output = {'name': [(subname, Tensor), (subname, Tensor)]}
                        sub_out = self.expects[out_name]
                        if not isinstance(sub_out, list):
                            raise AssertionError("sub_out type %s is not list",
                                                 type(sub_out))
                        for item in sub_out:
                            sub_out_name, expect = item[0], item[1]
1471 1472
                            self.compare_single_output_with_expect(
                                sub_out_name, expect)
1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
                    else:
                        expect = self.expects[out_name]
                        self.compare_single_output_with_expect(out_name, expect)

            def check(self):
                """
                return None means ok, raise Error means failed.

                the main enter point of Checker class
                """
1483
                self.init()
1484 1485 1486 1487
                self.calculate_output()
                self.compare_outputs_with_expects()

        class StaticChecker(Checker):
1488

1489 1490 1491
            def init(self):
                self.checker_name = "static checker"

1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
            def calculate_output(self):
                outs, fetch_list = self.op_test._calc_output(
                    place, no_check_set=no_check_set)
                self.outputs = outs
                self.fetch_list = fetch_list

            def find_actual_value(self, name):
                idx = find_actual(name, self.fetch_list)
                actual = self.outputs[idx]
                actual_t = np.array(actual)
                return actual, actual_t

            def convert_uint16_to_float_ifneed(self, actual_np, expect_np):
                """
                judge whether convert current output and expect to uint16.
                return True | False
                """
                if actual_np.dtype == np.uint16 and expect_np.dtype in [
                        np.float32, np.float64
                ]:
                    actual_np = convert_uint16_to_float(actual_np)
                    self.rtol = 1.e-2
                else:
                    self.rtol = 1.e-5
                if expect_np.dtype == np.uint16 and actual_np.dtype == np.uint16:
                    nonlocal atol
                    expect_np = convert_uint16_to_float(expect_np)
                    actual_np = convert_uint16_to_float(actual_np)
                    atol = max(atol, 0.03)
                return actual_np, expect_np

            def _compare_list(self, name, actual, expect):
                """ if expect is a tuple, we need to compare list.
                """
                self.op_test.assertListEqual(
                    actual.recursive_sequence_lengths(), expect[1],
                    "Output (" + name + ") has different lod at " + str(place))

        class DygraphChecker(Checker):
1531

1532 1533 1534
            def init(self):
                self.checker_name = "dygraph checker"

1535 1536 1537 1538 1539 1540 1541 1542
            def calculate_output(self):
                self.outputs = self.op_test._calc_dygraph_output(
                    place, no_check_set=no_check_set)

            def find_actual_value(self, name):
                with fluid.dygraph.base.guard(place=place):
                    imperative_actual = find_imperative_actual(
                        name, self.outputs, place)
1543 1544
                    imperative_actual_t = np.array(
                        imperative_actual.value().get_tensor())
1545 1546 1547
                    return imperative_actual, imperative_actual_t

            def convert_uint16_to_float_ifneed(self, actual_np, expect_np):
1548 1549 1550 1551 1552 1553
                if actual_np.dtype == np.uint16 and expect_np.dtype in [
                        np.float32, np.float64
                ]:
                    self.rtol = 1.e-2
                else:
                    self.rtol = 1.e-5
1554 1555 1556 1557
                if self.op_test.is_bfloat16_op():
                    if actual_np.dtype == np.uint16:
                        actual_np = convert_uint16_to_float(actual_np)
                    if expect_np.dtype == np.uint16:
X
xiongkun 已提交
1558
                        expect_np = convert_uint16_to_float(expect_np)
1559 1560 1561 1562 1563 1564 1565
                return actual_np, expect_np

            def _compare_list(self, name, actual, expect):
                """ if expect is a tuple, we need to compare list.
                """
                with fluid.dygraph.base.guard(place=place):
                    self.op_test.assertListEqual(
1566 1567
                        actual.value().get_tensor().recursive_sequence_lengths(
                        ), expect[1],
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
                        "Output (" + name + ") has different lod at " +
                        str(place) + " in dygraph mode")

            def _compare_numpy(self, name, actual_np, expect_np):
                if six.moves.reduce(lambda x, y: x * y, actual_np.shape,
                                    1) == 0 and six.moves.reduce(
                                        lambda x, y: x * y, expect_np.shape,
                                        1) == 0:
                    pass
                else:
                    self.op_test.assertTrue(
                        np.allclose(
                            actual_np,
                            expect_np,
                            atol=atol,
                            rtol=self.rtol if hasattr(self, 'rtol') else 1e-5,
                            equal_nan=equal_nan),
                        "Output (" + name + ") has diff at " + str(place) +
1586
                        " in " + self.checker_name)
1587 1588

        class EagerChecker(DygraphChecker):
1589

1590 1591 1592
            def init(self):
                self.checker_name = "eager checker"

1593 1594 1595
            def calculate_output(self):
                # we only check end2end api when check_eager=True
                with _test_eager_guard():
1596
                    self.is_python_api_test = True
1597 1598 1599
                    eager_dygraph_outs = self.op_test._calc_python_api_output(
                        place)
                    if eager_dygraph_outs is None:
X
xiongkun 已提交
1600
                        self.is_python_api_test = False
1601
                        # missing KernelSignature, fall back to eager middle output.
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
                        eager_dygraph_outs = self.op_test._calc_dygraph_output(
                            place, no_check_set=no_check_set)
                self.outputs = eager_dygraph_outs

            def _compare_numpy(self, name, actual_np, expect_np):
                with _test_eager_guard():
                    super()._compare_numpy(name, actual_np, expect_np)

            def convert_uint16_to_float_ifneed(self, actual_np, expect_np):
                with _test_eager_guard():
1612 1613
                    return super().convert_uint16_to_float_ifneed(
                        actual_np, expect_np)
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624

            def find_actual_value(self, name):
                with _test_eager_guard():
                    return super().find_actual_value(name)

            def _compare_list(self, name, actual, expect):
                """ if expect is a tuple, we need to compare list.
                """
                with _test_eager_guard():
                    super()._compare_list(name, actual, expect)

X
xiongkun 已提交
1625 1626 1627 1628 1629 1630 1631
            def _is_skip_name(self, name):
                # if in final state and kernel signature don't have name, then skip it.
                if self.is_python_api_test and hasattr(
                        self.op_test, "python_out_sig"
                ) and name not in self.op_test.python_out_sig:
                    return True
                return super()._is_skip_name(name)
1632

1633
        # set some flags by the combination of arguments.
X
xiongkun 已提交
1634
        self.infer_dtype_from_inputs_outputs(self.inputs, self.outputs)
1635 1636 1637 1638
        if self.dtype == np.float64 and \
            self.op_type not in op_threshold_white_list.NEED_FIX_FP64_CHECK_OUTPUT_THRESHOLD_OP_LIST:
            atol = 0

1639
        if self.is_bfloat16_op():
Y
Yiqun Liu 已提交
1640 1641
            if self.is_mkldnn_op():
                check_dygraph = False
1642
                check_eager = False
Y
Yiqun Liu 已提交
1643 1644 1645 1646 1647
                if hasattr(self, 'force_fp32_output') and getattr(
                        self, 'force_fp32_output'):
                    atol = 1e-2
                else:
                    atol = 2
1648
            else:
1649
                atol = 1e-1
1650

1651 1652 1653
        if no_check_set is not None:
            if self.op_type not in no_check_set_white_list.no_check_set_white_list:
                raise AssertionError(
X
xiongkun 已提交
1654
                    "no_check_set of op %s must be set to None." % self.op_type)
1655 1656 1657
        static_checker = StaticChecker(self, self.outputs)
        static_checker.check()
        outs, fetch_list = static_checker.outputs, static_checker.fetch_list
L
lujun 已提交
1658
        if check_dygraph:
1659 1660 1661
            # always enable legacy dygraph
            g_enable_legacy_dygraph()

1662 1663 1664
            dygraph_checker = DygraphChecker(self, self.outputs)
            dygraph_checker.check()
            dygraph_outs = dygraph_checker.outputs
1665 1666
            # yield the original state
            g_disable_legacy_dygraph()
1667
        if check_eager:
1668 1669 1670
            eager_checker = EagerChecker(self, self.outputs)
            eager_checker.check()
            eager_dygraph_outs = eager_checker.outputs
1671

C
cc 已提交
1672
        # Note(zhiqiu): inplace_atol should be only set when op doesn't ensure
L
Leo Chen 已提交
1673 1674
        # computational consistency.
        # For example, group_norm uses AtomicAdd on CUDAPlace, which do not ensure
C
cc 已提交
1675
        # computation order when multiple threads write the same address. So the
L
Leo Chen 已提交
1676 1677 1678
        # result of group_norm is non-deterministic when datatype is float.
        # When inplace_atol is not None, the inplace check uses numpy.allclose
        # to check inplace result instead of numpy.array_equal.
1679 1680
        if inplace_atol is not None:
            warnings.warn(
L
Leo Chen 已提交
1681 1682
                "inplace_atol should only be set when op doesn't ensure computational consistency, please check it!"
            )
1683
        # Check inplace for given op, its grad op, its grad_grad op, etc.
C
cc 已提交
1684
        # No effect on original OpTest
1685
        # Currently not support ParallelExecutor on XPUPlace.
1686
        if not paddle.is_compiled_with_xpu(
1687
        ) and not paddle.is_compiled_with_npu(
1688 1689
        ) and not paddle.is_compiled_with_mlu() and not isinstance(
                place, core.CustomPlace):
1690 1691 1692
            self.check_inplace_output_with_place(place,
                                                 no_check_set=no_check_set,
                                                 inplace_atol=inplace_atol)
1693

1694 1695 1696
        if check_eager:
            return outs, dygraph_outs, eager_dygraph_outs, fetch_list
        elif check_dygraph:
1697 1698 1699 1700 1701
            return outs, dygraph_outs, fetch_list
        else:
            return outs, fetch_list

    def check_compile_vs_runtime(self, fetch_list, fetch_outs):
1702

1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
        def find_fetch_index(target_name, fetch_list):
            found = [
                i for i, var_name in enumerate(fetch_list)
                if var_name == target_name
            ]
            if len(found) == 0:
                return -1
            else:
                self.assertTrue(
                    len(found) == 1,
                    "Found {} {}".format(len(found), target_name))
                return found[0]

        for name in self.op.desc.output_names():
            var_names = self.op.desc.output(name)
            for var_name in var_names:
                i = find_fetch_index(var_name, fetch_list)
                if i == -1:
                    # The output is dispensiable or intermediate.
                    break
                out = fetch_outs[i]
                if isinstance(out, core.LoDTensor):
                    lod_level_runtime = len(out.lod())
                else:
                    if isinstance(out, core.LoDTensorArray):
                        warnings.warn(
                            "The check of LoDTensorArray's lod_level is not implemented now!"
                        )
                    lod_level_runtime = 0

                var = self.program.global_block().var(var_name)
                if var.type == core.VarDesc.VarType.LOD_TENSOR:
                    lod_level_compile = var.lod_level
                else:
                    lod_level_compile = 0
                self.assertEqual(
                    lod_level_compile, lod_level_runtime,
                    "The lod_level of Output (" + name +
                    ") is different between compile-time and runtime (" +
                    str(lod_level_compile) + " vs " + str(lod_level_runtime) +
                    ")")

1745
    def _get_places(self):
D
dzhwinter 已提交
1746 1747 1748 1749 1750 1751
        if self.dtype == np.float16:
            if core.is_compiled_with_cuda() and core.op_support_gpu(
                    self.op_type):
                place = core.CUDAPlace(0)
                if core.is_float16_supported(place):
                    return [place]
W
Wu Yi 已提交
1752 1753
                else:
                    return []
D
dzhwinter 已提交
1754 1755
            else:
                return []
1756
        places = [fluid.CPUPlace()]
1757 1758 1759
        cpu_only = self._cpu_only if hasattr(self, '_cpu_only') else False
        if core.is_compiled_with_cuda() and core.op_support_gpu(self.op_type)\
           and not cpu_only:
D
dzhwinter 已提交
1760
            places.append(core.CUDAPlace(0))
1761 1762
        return places

M
minqiyang 已提交
1763 1764 1765 1766
    def check_output(self,
                     atol=1e-5,
                     no_check_set=None,
                     equal_nan=False,
1767
                     check_dygraph=True,
1768 1769
                     inplace_atol=None,
                     check_eager=False):
1770
        self.__class__.op_type = self.op_type
Y
Yiqun Liu 已提交
1771
        if self.is_mkldnn_op():
1772
            self.__class__.use_mkldnn = True
C
cc 已提交
1773

Y
Yiqun Liu 已提交
1774
        if self.is_xpu_op():
1775 1776
            self.__class__.use_xpu = True

1777
        places = self._get_places()
Q
qijun 已提交
1778
        for place in places:
1779 1780 1781 1782 1783 1784 1785
            res = self.check_output_with_place(place,
                                               atol,
                                               no_check_set,
                                               equal_nan,
                                               check_dygraph,
                                               inplace_atol,
                                               check_eager=check_eager)
1786 1787 1788 1789
            if check_eager:
                assert check_dygraph == True
                outs, dygraph_outs, eager_dygraph_outs, fetch_list = res
            elif check_dygraph:
1790 1791 1792
                outs, dygraph_outs, fetch_list = res
            else:
                outs, fetch_list = res
1793
            if self.op_type not in compile_vs_runtime_white_list.COMPILE_RUN_OP_WHITE_LIST:
1794
                self.check_compile_vs_runtime(fetch_list, outs)
Q
qijun 已提交
1795

P
pangyoki 已提交
1796
    def check_output_customized(self, checker, custom_place=None):
1797
        places = self._get_places()
P
pangyoki 已提交
1798 1799
        if custom_place:
            places.append(custom_place)
1800 1801 1802
        for place in places:
            outs = self.calc_output(place)
            outs = [np.array(out) for out in outs]
1803
            outs.sort(key=len)
1804 1805
            checker(outs)

1806 1807 1808 1809 1810 1811
    def check_output_with_place_customized(self, checker, place):
        outs = self.calc_output(place)
        outs = [np.array(out) for out in outs]
        outs.sort(key=len)
        checker(outs)

D
Dun 已提交
1812 1813
    def _assert_is_close(self, numeric_grads, analytic_grads, names,
                         max_relative_error, msg_prefix):
M
minqiyang 已提交
1814
        for a, b, name in six.moves.zip(numeric_grads, analytic_grads, names):
1815 1816 1817 1818 1819 1820
            # It asserts np.abs(a - b) / np.abs(a) < max_relative_error, in which
            # max_relative_error is 1e-7. According to the value of np.abs(a), we
            # change np.abs(a) to achieve dynamic threshold. For example, if
            # the value of np.abs(a) is between 1e-10 and 1e-8, we set np.abs(a)*=1e4.
            # Therefore, it asserts np.abs(a - b) / (np.abs(a)*1e4) < max_relative_error,
            # which is the same as np.abs(a - b) / np.abs(a) < max_relative_error*1e4.
1821
            abs_a = np.abs(a)
1822 1823 1824 1825 1826
            if self.dtype == np.float64 and \
                self.op_type not in op_threshold_white_list.NEED_FIX_FP64_CHECK_GRAD_THRESHOLD_OP_LIST:
                abs_a[abs_a < 1e-10] = 1e-3
                abs_a[np.logical_and(abs_a > 1e-10, abs_a <= 1e-8)] *= 1e4
                abs_a[np.logical_and(abs_a > 1e-8, abs_a <= 1e-6)] *= 1e2
1827 1828
            elif self.is_bfloat16_op():
                abs_a[abs_a < 1e-2] = 1
1829 1830
            else:
                abs_a[abs_a < 1e-3] = 1
1831 1832 1833 1834 1835 1836

            diff_mat = np.abs(a - b) / abs_a
            max_diff = np.max(diff_mat)

            def err_msg():
                offset = np.argmax(diff_mat > max_relative_error)
1837 1838 1839
                return ("Operator %s error, %s variable %s (shape: %s, dtype: %s) max gradient diff %e over limit %e, "
                    "the first error element is %d, expected %e, but got %e.") \
                    % (self.op_type, msg_prefix, name, str(a.shape), self.dtype, max_diff, max_relative_error,
1840
                    offset, a.flatten()[offset], b.flatten()[offset])
1841 1842 1843

            self.assertLessEqual(max_diff, max_relative_error, err_msg())

1844 1845 1846 1847 1848 1849 1850
    def _check_grad_helper(self):
        self.infer_dtype_from_inputs_outputs(self.inputs, self.outputs)
        self.__class__.op_type = self.op_type
        self.__class__.exist_check_grad = True
        if self.dtype == np.float64:
            self.__class__.exist_fp64_check_grad = True

1851 1852
    def check_grad(self,
                   inputs_to_check,
Y
Yancey 已提交
1853
                   output_names,
1854
                   no_grad_set=None,
1855
                   numeric_grad_delta=0.005,
1856
                   in_place=False,
Q
Qiao Longfei 已提交
1857
                   max_relative_error=0.005,
1858
                   user_defined_grads=None,
1859
                   user_defined_grad_outputs=None,
1860 1861
                   check_dygraph=True,
                   check_eager=False):
1862
        self._check_grad_helper()
1863
        places = self._get_places()
1864
        for place in places:
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
            self.check_grad_with_place(place,
                                       inputs_to_check,
                                       output_names,
                                       no_grad_set,
                                       numeric_grad_delta,
                                       in_place,
                                       max_relative_error,
                                       user_defined_grads,
                                       user_defined_grad_outputs,
                                       check_dygraph,
                                       check_eager=check_eager)
1876 1877 1878 1879 1880 1881 1882 1883 1884

    def check_grad_with_place(self,
                              place,
                              inputs_to_check,
                              output_names,
                              no_grad_set=None,
                              numeric_grad_delta=0.005,
                              in_place=False,
                              max_relative_error=0.005,
1885
                              user_defined_grads=None,
1886
                              user_defined_grad_outputs=None,
1887
                              check_dygraph=True,
1888 1889
                              numeric_place=None,
                              check_eager=False):
1890
        self.scope = core.Scope()
Q
qijun 已提交
1891
        op_inputs = self.inputs if hasattr(self, "inputs") else dict()
1892
        op_outputs = self.outputs if hasattr(self, "outputs") else dict()
Q
qijun 已提交
1893
        op_attrs = self.attrs if hasattr(self, "attrs") else dict()
P
phlrain 已提交
1894

Y
Yiqun Liu 已提交
1895 1896
        self._check_grad_helper()
        if self.is_bfloat16_op() and self.is_mkldnn_op():
1897
            check_dygraph = False
1898
            check_eager = False
1899

1900 1901 1902 1903
        if self.dtype == np.float64 and \
            self.op_type not in op_threshold_white_list.NEED_FIX_FP64_CHECK_GRAD_THRESHOLD_OP_LIST:
            numeric_grad_delta = 1e-5
            max_relative_error = 1e-7
1904

P
phlrain 已提交
1905 1906 1907
        cache_list = None
        if hasattr(self, "cache_name_list"):
            cache_list = self.cache_name_list
1908 1909 1910 1911 1912 1913 1914

        # oneDNN numeric gradient should use CPU kernel
        use_onednn = False
        if "use_mkldnn" in op_attrs and op_attrs["use_mkldnn"] == True:
            op_attrs["use_mkldnn"] = False
            use_onednn = True

1915 1916 1917 1918 1919 1920
        self.op = create_op(self.scope,
                            self.op_type,
                            op_inputs,
                            op_outputs,
                            op_attrs,
                            cache_list=cache_list)
Y
Yu Yang 已提交
1921

1922 1923 1924
        if use_onednn:
            op_attrs["use_mkldnn"] = True

1925 1926
        if no_grad_set is None:
            no_grad_set = set()
1927 1928
        else:
            if (self.op_type not in no_grad_set_white_list.NEED_TO_FIX_OP_LIST
1929 1930 1931
                ) and (self.op_type
                       not in no_grad_set_white_list.NOT_CHECK_OP_LIST) and (
                           not self.is_bfloat16_op()):
1932 1933
                raise AssertionError("no_grad_set must be None, op_type is " +
                                     self.op_type + " Op.")
1934

1935 1936 1937 1938 1939 1940 1941 1942
        for input_to_check in inputs_to_check:
            set_input(self.scope, self.op, self.inputs, place)
            tensor_to_check = self.scope.find_var(input_to_check).get_tensor()
            tensor_size = six.moves.reduce(lambda a, b: a * b,
                                           tensor_to_check.shape(), 1)
            if tensor_size < 100:
                self.__class__.input_shape_is_large = False

Y
Yancey 已提交
1943 1944 1945
        if not type(output_names) is list:
            output_names = [output_names]

1946 1947 1948
        if numeric_place is None:
            numeric_place = place

Q
Qiao Longfei 已提交
1949
        numeric_grads = user_defined_grads or [
1950 1951 1952 1953 1954 1955 1956 1957 1958
            get_numeric_gradient(numeric_place,
                                 self.scope,
                                 self.op,
                                 self.inputs,
                                 input_to_check,
                                 output_names,
                                 delta=numeric_grad_delta,
                                 in_place=in_place)
            for input_to_check in inputs_to_check
1959
        ]
1960
        analytic_grads = self._get_gradient(inputs_to_check, place,
1961 1962
                                            output_names, no_grad_set,
                                            user_defined_grad_outputs)
1963 1964
        # comparison of bf16 results will happen as fp32
        # loop over list of grads and convert bf16 to fp32
1965
        fp32_analytic_grads = []
1966 1967 1968
        for grad in analytic_grads:
            if grad.dtype == np.uint16:
                grad = convert_uint16_to_float(grad)
1969
                max_relative_error = 0.04 if max_relative_error < 0.04 else max_relative_error
1970 1971 1972 1973 1974 1975 1976
            fp32_analytic_grads.append(grad)
        analytic_grads = fp32_analytic_grads

        fp32_numeric_grads = []
        for grad in numeric_grads:
            if grad.dtype == np.uint16:
                grad = convert_uint16_to_float(grad)
1977
                max_relative_error = 0.04 if max_relative_error < 0.04 else max_relative_error
1978 1979
            fp32_numeric_grads.append(grad)
        numeric_grads = fp32_numeric_grads
1980

D
Dun 已提交
1981 1982 1983
        self._assert_is_close(numeric_grads, analytic_grads, inputs_to_check,
                              max_relative_error,
                              "Gradient Check On %s" % str(place))
Q
qijun 已提交
1984

1985
        if check_dygraph:
1986 1987 1988
            # ensure switch into legacy dygraph
            g_enable_legacy_dygraph()

1989 1990 1991 1992
            dygraph_grad = self._get_dygraph_grad(inputs_to_check, place,
                                                  output_names,
                                                  user_defined_grad_outputs,
                                                  no_grad_set, False)
1993 1994 1995 1996
            fp32_grads = []
            for grad in dygraph_grad:
                if grad.dtype == np.uint16:
                    grad = convert_uint16_to_float(grad)
1997
                    max_relative_error = 0.03 if max_relative_error < 0.03 else max_relative_error
1998 1999
                fp32_grads.append(grad)
            dygraph_grad = fp32_grads
2000 2001 2002
            self._assert_is_close(numeric_grads, dygraph_grad, inputs_to_check,
                                  max_relative_error,
                                  "Gradient Check On %s" % str(place))
2003 2004
            # ensure switch back eager dygraph
            g_disable_legacy_dygraph()
2005

2006
        if check_eager:
J
Jiabin Yang 已提交
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
            with fluid.dygraph.base.guard(place):
                with _test_eager_guard():
                    eager_dygraph_grad = self._get_dygraph_grad(
                        inputs_to_check, place, output_names,
                        user_defined_grad_outputs, no_grad_set, check_eager)
                    fp32_grads = []
                    for grad in eager_dygraph_grad:
                        if grad.dtype == np.uint16:
                            grad = convert_uint16_to_float(grad)
                            max_relative_error = 0.03 if max_relative_error < 0.03 else max_relative_error
                        fp32_grads.append(grad)
                    eager_dygraph_grad = fp32_grads
                    self._assert_is_close(numeric_grads, eager_dygraph_grad,
                                          inputs_to_check, max_relative_error,
                                          "Gradient Check On %s" % str(place))
2022

2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035
    def _find_var_in_dygraph(self, output_vars, name):
        if name in output_vars:
            return output_vars[name]
        else:
            for output_vars_index in output_vars:
                for output_vars_selected in output_vars[output_vars_index]:
                    if output_vars_selected.name == name:
                        return output_vars_selected

    def _get_dygraph_grad(self,
                          inputs_to_check,
                          place,
                          output_names,
2036
                          user_defined_grad_outputs=None,
2037 2038
                          no_grad_set=None,
                          check_eager=False):
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
        with fluid.dygraph.base.guard(place=place):
            block = fluid.default_main_program().global_block()

            op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)

            # prepare input variable
            inputs, inputs_grad_dict = self.append_input_output_for_dygraph(
                op_proto, self.inputs, True, True, block)

            # prepare output variable
            outputs = self.append_input_output_for_dygraph(
                op_proto, self.outputs, False, False, block)

2052
            # prepare attributes
2053 2054 2055 2056 2057
            attrs_outputs = {}
            if hasattr(self, "attrs"):
                for attrs_name in self.attrs:
                    if self.attrs[attrs_name] is not None:
                        attrs_outputs[attrs_name] = self.attrs[attrs_name]
2058

2059
            if check_eager:
2060 2061
                eager_outputs = self._calc_python_api_output(
                    place, inputs, outputs)
2062
            # if outputs is None, kernel sig is empty or other error is happens.
X
xiongkun 已提交
2063
            if not check_eager or eager_outputs is None:
2064 2065 2066 2067 2068
                block.append_op(
                    type=self.op_type,
                    inputs=inputs,
                    outputs=outputs,
                    attrs=attrs_outputs if hasattr(self, "attrs") else None)
X
xiongkun 已提交
2069 2070
            else:
                outputs = eager_outputs
2071

2072 2073 2074
            if self.dtype == np.uint16:
                cast_inputs = self._find_var_in_dygraph(outputs,
                                                        output_names[0])
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
                cast_outputs = block.create_var(dtype="float32",
                                                shape=cast_inputs[0].shape)
                cast_op = block.append_op(inputs={"X": cast_inputs},
                                          outputs={"Out": cast_outputs},
                                          type="cast",
                                          attrs={
                                              "in_dtype":
                                              core.VarDesc.VarType.BF16,
                                              "out_dtype":
                                              core.VarDesc.VarType.FP32
                                          })
2086 2087
                outputs = {output_names[0]: cast_outputs}

2088 2089 2090 2091 2092
            outputs_valid = {}
            for output_name in output_names:
                outputs_valid[output_name] = self._find_var_in_dygraph(
                    outputs, output_name)

2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
            if user_defined_grad_outputs is None:
                if len(outputs_valid) == 1:
                    loss = block.create_var(
                        dtype=self.dtype,
                        type=core.VarDesc.VarType.LOD_TENSOR,
                        persistable=False,
                        stop_gradient=False,
                        shape=[1])
                    for outputs_valid_key in outputs_valid:
                        block.append_op(
                            type="mean",
                            inputs={"X": outputs_valid[outputs_valid_key]},
                            outputs={"Out": [loss]},
                            attrs=None)
                else:
                    avg_sum = []
                    for cur_loss in outputs_valid:
                        cur_avg_loss = block.create_var(
                            dtype=self.dtype,
                            type=core.VarDesc.VarType.LOD_TENSOR,
                            persistable=False,
                            stop_gradient=False)
2115 2116 2117 2118
                        block.append_op(type="mean",
                                        inputs={"X": outputs_valid[cur_loss]},
                                        outputs={"Out": [cur_avg_loss]},
                                        attrs=None)
2119 2120 2121 2122 2123 2124 2125
                        avg_sum.append(cur_avg_loss)
                    loss_sum = block.create_var(
                        dtype=self.dtype,
                        type=core.VarDesc.VarType.LOD_TENSOR,
                        persistable=False,
                        stop_gradient=False,
                        shape=[1])
2126 2127 2128 2129
                    block.append_op(type='sum',
                                    inputs={"X": avg_sum},
                                    outputs={"Out": loss_sum},
                                    attrs=None)
2130
                    loss = block.create_var(
2131 2132 2133
                        dtype=self.dtype,
                        type=core.VarDesc.VarType.LOD_TENSOR,
                        persistable=False,
2134 2135
                        stop_gradient=False,
                        shape=[1])
2136 2137 2138 2139
                    block.append_op(type='scale',
                                    inputs={"X": loss_sum},
                                    outputs={"Out": loss},
                                    attrs={'scale': 1.0 / float(len(avg_sum))})
2140
                loss.backward()
2141

2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
                fetch_list_grad = []
                for inputs_to_check_name in inputs_to_check:
                    a = inputs_grad_dict[inputs_to_check_name].gradient()
                    fetch_list_grad.append(a)
                return fetch_list_grad
            else:
                # user_defined_grad_outputs here are numpy arrays
                if not isinstance(user_defined_grad_outputs, list):
                    user_defined_grad_outputs = [user_defined_grad_outputs]
                grad_outputs = []
                for grad_out_value in user_defined_grad_outputs:
                    grad_outputs.append(paddle.to_tensor(grad_out_value))
2154
                # delete the inputs which no need to calculate grad
C
chentianyu03 已提交
2155 2156 2157
                for no_grad_val in no_grad_set:
                    del (inputs[no_grad_val])

J
Jiabin Yang 已提交
2158
                if not _in_legacy_dygraph():
2159 2160
                    core.eager.run_backward(fluid.layers.utils.flatten(outputs),
                                            grad_outputs, False)
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171
                    grad_inputs = []
                    for inputs_list in inputs.values():
                        for inp in inputs_list:
                            grad_inputs.append(inp.grad.numpy())
                    return grad_inputs
                else:
                    grad_inputs = paddle.grad(
                        outputs=fluid.layers.utils.flatten(outputs),
                        inputs=fluid.layers.utils.flatten(inputs),
                        grad_outputs=grad_outputs)
                    return [grad.numpy() for grad in grad_inputs]
2172

Y
Yu Yang 已提交
2173 2174 2175 2176 2177
    @staticmethod
    def _numpy_to_lod_tensor(np_value, lod, place):
        tensor = core.LoDTensor()
        tensor.set(np_value, place)
        if lod is not None:
2178
            tensor.set_recursive_sequence_lengths(lod)
Y
Yu Yang 已提交
2179 2180
        return tensor

K
Kexin Zhao 已提交
2181
    @staticmethod
K
Kexin Zhao 已提交
2182 2183
    def np_dtype_to_fluid_dtype(input):
        return input
K
Kexin Zhao 已提交
2184

D
dzhwinter 已提交
2185 2186 2187 2188 2189 2190 2191 2192
    @staticmethod
    def fluid_dtype_to_np_dtype(self, dtype):
        return dtype

    @staticmethod
    def np_value_to_fluid_value(input):
        return input

2193 2194 2195 2196 2197
    def _get_gradient(self,
                      input_to_check,
                      place,
                      output_names,
                      no_grad_set,
2198
                      user_defined_grad_outputs=None,
2199
                      parallel=False):
Y
Yu Yang 已提交
2200
        prog = Program()
2201
        scope = core.Scope()
Y
Yu Yang 已提交
2202
        block = prog.global_block()
2203
        self._append_ops(block)
Y
Yu Yang 已提交
2204

2205
        inputs = self._get_inputs(block)
2206
        outputs = self._get_outputs(block)
2207
        feed_dict = self.feed_var(inputs, place)
Y
Yu Yang 已提交
2208

2209
        if user_defined_grad_outputs is None:
2210 2211
            if self.dtype == np.uint16:
                cast_inputs = list(map(block.var, output_names))
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
                cast_outputs = block.create_var(dtype="float32",
                                                shape=cast_inputs[0].shape)
                cast_op = block.append_op(inputs={"X": cast_inputs},
                                          outputs={"Out": cast_outputs},
                                          type="cast",
                                          attrs={
                                              "in_dtype":
                                              core.VarDesc.VarType.BF16,
                                              "out_dtype":
                                              core.VarDesc.VarType.FP32
                                          })
2223 2224 2225
                cast_op.desc.infer_var_type(block.desc)
                cast_op.desc.infer_shape(block.desc)
                output_names = [cast_outputs.name]
2226
            loss = append_loss_ops(block, output_names)
2227 2228 2229
            param_grad_list = append_backward(loss=loss,
                                              parameter_list=input_to_check,
                                              no_grad_set=no_grad_set)
2230 2231 2232 2233 2234 2235 2236 2237 2238
            fetch_list = [g for p, g in param_grad_list]
        else:
            assert parallel is False, "unsupported parallel mode when giving custom grad outputs."
            # user_defined_grad_outputs here are numpy arrays
            if not isinstance(user_defined_grad_outputs, list):
                user_defined_grad_outputs = [user_defined_grad_outputs]
            grad_outputs = []
            for grad_out_value in user_defined_grad_outputs:
                # `presistable` is used to avoid executor create new var in local scope
2239 2240 2241
                var = block.create_var(shape=grad_out_value.shape,
                                       dtype=grad_out_value.dtype,
                                       persistable=True)
2242 2243 2244 2245 2246 2247 2248
                true_var = scope.var(var.name)
                tensor = true_var.get_tensor()
                tensor.set(grad_out_value, place)
                grad_outputs.append(var)
            targets = [
                outputs[name] for name in outputs if name in output_names
            ]
2249
            inputs = [inputs[name] for name in input_to_check if name in inputs]
2250 2251 2252 2253
            grad_inputs = paddle.static.gradients(targets, inputs, grad_outputs,
                                                  no_grad_set)
            fetch_list = grad_inputs

2254 2255
        if parallel:
            use_cuda = False
2256
            if isinstance(place, fluid.CUDAPlace):
2257
                use_cuda = True
2258 2259 2260 2261
            compiled_prog = fluid.CompiledProgram(prog).with_data_parallel(
                loss_name=loss.name, places=place)
            prog = compiled_prog
        executor = fluid.Executor(place)
2262
        return list(
2263 2264
            map(
                np.array,
2265 2266 2267 2268 2269
                executor.run(prog,
                             feed_dict,
                             fetch_list,
                             scope=scope,
                             return_numpy=False)))
A
arlesniak 已提交
2270 2271 2272


class OpTestTool:
2273

A
arlesniak 已提交
2274 2275 2276 2277 2278 2279 2280
    @classmethod
    def skip_if(cls, condition: object, reason: str):
        return unittest.skipIf(condition, reason)

    @classmethod
    def skip_if_not_cpu_bf16(cls):
        return OpTestTool.skip_if(
2281 2282
            not (isinstance(_current_expected_place(), core.CPUPlace)
                 and core.supports_bfloat16()),
A
arlesniak 已提交
2283
            "Place does not support BF16 evaluation")
2284 2285 2286 2287 2288 2289

    @classmethod
    def skip_if_not_cpu(cls):
        return OpTestTool.skip_if(
            not isinstance(_current_expected_place(), core.CPUPlace),
            "OneDNN supports only CPU for now")