From 021add6121766d5b9c4629446486d5c3eb057fea Mon Sep 17 00:00:00 2001 From: Jacek Czaja Date: Tue, 12 Oct 2021 10:55:13 +0200 Subject: [PATCH 1/7] remove not needed log (#36348) --- log | Bin 2816 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 log diff --git a/log b/log deleted file mode 100644 index c02e10686b5fbcc78a8591519aaa3389dac63a56..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2816 zcmds3U2oeq6y39b#f5-jGORjC+XWlj1V|&dE9Sb{>LA+_L5s9agdzo!vg5V=@4b}l zN{;O`8L$DHUnG;_<+Ngtf*xLf+~HQ<9(CS(yv%TQ-B~Xgn9-=ByB4rcm7iO!M^x;DvU^LS8x# z69JN=1(`9`kGkC#o$oI1L5vXT%rf49mYUvfFFgkLHd1G%K4-PLAKV&v)Y#kbcK8{! z+vbjhgD@uyWWTFcn z1IDRkxmX%|Lr9v+94c8q9w%^olEAa437kCtyr19J{l`Bw0D3)`92JanC61=5l>BHD z2uJyi;#$)RPk-L&d69=b0WbZk5E_BN7#;cg{@U0jvmCu@xNCM_vFs*n!zru{^D@s@ zw6HRlUM>O~_no5!L*L!O<7b^-rkHc^?$=>D8vTMIDPc$E0*RD*Hm>+9%88O02{#@1 zEUv*}7U-GO0_sNs8&(Lp405!D*}x|2Z)segL5}fICTQGVxiAM8q z?Z?rzHJB&0!7AObf5RW^)_Z`tK`XlvP3ZWnLQ?~HCvsy~C=cgS(dm z)ri-&-iA3c%o{k^VW)ur12U#VsmJ*PM~`O-JWuYa_R)_xep*BZ6SSnw W5 Date: Tue, 12 Oct 2021 17:25:28 +0800 Subject: [PATCH 2/7] delete remove_static_file() function in error.py (#36153) * change time to remove static tempfile * delete remove_static_file() function --- .../fluid/dygraph/dygraph_to_static/error.py | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/python/paddle/fluid/dygraph/dygraph_to_static/error.py b/python/paddle/fluid/dygraph/dygraph_to_static/error.py index 2a975bf00d1d2..273961e27efba 100644 --- a/python/paddle/fluid/dygraph/dygraph_to_static/error.py +++ b/python/paddle/fluid/dygraph/dygraph_to_static/error.py @@ -54,27 +54,9 @@ def attach_error_data(error, in_runtime=False): setattr(error, ERROR_DATA, error_data) - remove_static_file() return error -def remove_static_file(): - """ - Removes temporary files created during the transformation of dygraph to static graph. - """ - del_files = set() - for loc in global_origin_info_map: - static_filepath = loc[0] - del_files.add(static_filepath) - - filename, extension = os.path.splitext(static_filepath) - del_files.add(filename + ".pyc") - - for filepath in del_files: - if os.path.exists(filepath): - os.remove(filepath) - - class TraceBackFrame(OriginInfo): """ Traceback frame information. From 6920afeb5edadf836a7f7da30bba6efbb6380f05 Mon Sep 17 00:00:00 2001 From: Zhou Wei <1183042833@qq.com> Date: Tue, 12 Oct 2021 17:32:59 +0800 Subject: [PATCH 3/7] fix windows bug that python virtual env can't find python executable (#36227) --- python/paddle/dataset/image.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/python/paddle/dataset/image.py b/python/paddle/dataset/image.py index 4fd7dc0d37ff8..c36213282c59c 100644 --- a/python/paddle/dataset/image.py +++ b/python/paddle/dataset/image.py @@ -39,10 +39,12 @@ if six.PY3: import subprocess import sys - if sys.platform == 'win32': - interpreter = sys.exec_prefix + "\\" + "python.exe" - else: - interpreter = sys.executable + import os + interpreter = sys.executable + # Note(zhouwei): if use Python/C 'PyRun_SimpleString', 'sys.executable' + # will be the C++ execubable on Windows + if sys.platform == 'win32' and 'python.exe' not in interpreter: + interpreter = sys.exec_prefix + os.sep + 'python.exe' import_cv2_proc = subprocess.Popen( [interpreter, "-c", "import cv2"], stdout=subprocess.PIPE, From 5f1eb839f9de416476fc70c13b6457cfee1c831d Mon Sep 17 00:00:00 2001 From: Aganlengzi Date: Tue, 12 Oct 2021 18:19:37 +0800 Subject: [PATCH 4/7] [NPU] concat supports dtype int64 for model deepfm (#36327) * [NPU] modify for model deepfm * [NPU] unit test delete precision control * [NPU] add more unit test * revert elementwise_mul related modification * [NPU] add more unit tests for concat --- paddle/fluid/operators/concat_op_npu.cc | 6 + .../tests/unittests/npu/test_concat_op_npu.py | 171 ++++++++++++++---- 2 files changed, 145 insertions(+), 32 deletions(-) diff --git a/paddle/fluid/operators/concat_op_npu.cc b/paddle/fluid/operators/concat_op_npu.cc index d242c9f8c3fbd..109007d737c15 100644 --- a/paddle/fluid/operators/concat_op_npu.cc +++ b/paddle/fluid/operators/concat_op_npu.cc @@ -122,8 +122,14 @@ namespace ops = paddle::operators; REGISTER_OP_NPU_KERNEL(concat, ops::ConcatNPUKernel, ops::ConcatNPUKernel, +#ifdef PADDLE_WITH_ASCEND_INT64 + ops::ConcatNPUKernel, +#endif ops::ConcatNPUKernel); REGISTER_OP_NPU_KERNEL(concat_grad, ops::ConcatGradNPUKernel, ops::ConcatGradNPUKernel, +#ifdef PADDLE_WITH_ASCEND_INT64 + ops::ConcatGradNPUKernel, +#endif ops::ConcatGradNPUKernel); diff --git a/python/paddle/fluid/tests/unittests/npu/test_concat_op_npu.py b/python/paddle/fluid/tests/unittests/npu/test_concat_op_npu.py index 8f11d00ccabf6..f9eecefdfb237 100644 --- a/python/paddle/fluid/tests/unittests/npu/test_concat_op_npu.py +++ b/python/paddle/fluid/tests/unittests/npu/test_concat_op_npu.py @@ -18,7 +18,7 @@ import unittest import sys sys.path.append("..") -from op_test import OpTest +from op_test import OpTest, skip_check_grad_ci import paddle import paddle.fluid as fluid @@ -26,7 +26,7 @@ SEED = 2021 -class TestConcat(OpTest): +class TestConcatOp(OpTest): def setUp(self): self.set_npu() self.op_type = "concat" @@ -56,54 +56,161 @@ def init_dtype(self): def test_check_output(self): self.check_output_with_place(self.place) + def test_check_grad(self): + self.check_grad_with_place(self.place, ['x0', 'x2'], 'Out') + self.check_grad_with_place(self.place, ['x1'], 'Out') + self.check_grad_with_place(self.place, ['x2'], 'Out') + def init_test_data(self): self.x0 = np.random.random((1, 4, 50)).astype(self.dtype) self.x1 = np.random.random((2, 4, 50)).astype(self.dtype) self.x2 = np.random.random((3, 4, 50)).astype(self.dtype) self.axis = 0 + +class TestConcatOp2(TestConcatOp): + def init_test_data(self): + self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.axis = 1 + + +@skip_check_grad_ci( + reason="The function 'check_grad' for large inputs is too slow.") +class TestConcatOp3(TestConcatOp): + def init_test_data(self): + self.x0 = np.random.random((1, 256, 170, 256)).astype(self.dtype) + self.x1 = np.random.random((1, 128, 170, 256)).astype(self.dtype) + self.x2 = np.random.random((1, 128, 170, 256)).astype(self.dtype) + self.axis = 1 + def test_check_grad(self): - self.check_grad_with_place(self.place, ['x0', 'x2'], 'Out') - self.check_grad_with_place(self.place, ['x1'], 'Out') - self.check_grad_with_place(self.place, ['x2'], 'Out') + pass + + +@skip_check_grad_ci( + reason="This test will meet fetch error when there is a null grad. The detailed information is in PR#17015." +) +class TestConcatOp4(TestConcatOp): + def init_test_data(self): + self.x0 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((2, 3, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((0, 3, 4, 5)).astype(self.dtype) + self.axis = 0 + + def test_check_grad(self): + pass + + +class TestConcatOp5(TestConcatOp): + def init_test_data(self): + self.x0 = np.random.random((5, 1, 4, 5)).astype(self.dtype) + self.x1 = np.random.random((5, 2, 4, 5)).astype(self.dtype) + self.x2 = np.random.random((5, 3, 4, 5)).astype(self.dtype) + self.axis = -3 + + +#----------------Concat Fp16---------------- +def create_test_fp16(parent): + class TestConcatFp16(parent): + def init_dtype(self): + self.dtype = np.float16 + + cls_name = "{0}_{1}".format(parent.__name__, "Fp16") + TestConcatFp16.__name__ = cls_name + globals()[cls_name] = TestConcatFp16 + + +create_test_fp16(TestConcatOp) +create_test_fp16(TestConcatOp2) +create_test_fp16(TestConcatOp3) +create_test_fp16(TestConcatOp4) +create_test_fp16(TestConcatOp5) + + +#----------------Concat Int64---------------- +def create_test_int64(parent): + class TestConcatInt64(parent): + def init_dtype(self): + self.dtype = np.int64 + def test_check_grad(self): + pass + + cls_name = "{0}_{1}".format(parent.__name__, "Int64") + TestConcatInt64.__name__ = cls_name + globals()[cls_name] = TestConcatInt64 + + +create_test_int64(TestConcatOp) +create_test_int64(TestConcatOp2) +create_test_int64(TestConcatOp3) +create_test_int64(TestConcatOp4) +create_test_int64(TestConcatOp5) + + +class TestConcatAPIWithLoDTensorArray(unittest.TestCase): + """ + Test concat api when the input(x) is a LoDTensorArray. + """ -class TestConcatFP16(OpTest): def setUp(self): self.set_npu() - self.op_type = "concat" self.place = paddle.NPUPlace(0) - self.init_dtype() - self.init_test_data() - - self.inputs = {'X': [('x0', self.x0), ('x1', self.x1), ('x2', self.x2)]} - self.attrs = {'axis': self.axis} - if self.axis < 0: - self.actual_axis = self.axis + len(self.x0.shape) - self.actual_axis = self.actual_axis if self.actual_axis > 0 else 0 + self.axis = 1 + self.iter_num = 3 + self.input_shape = [2, 3] + self.x = np.random.random(self.input_shape).astype("float32") + + def set_program(self, use_fluid_api): + paddle.enable_static() + if use_fluid_api: + self.program = fluid.Program() + with fluid.program_guard(self.program): + input = fluid.layers.assign(self.x) + tensor_array = fluid.layers.create_array(dtype='float32') + zero = fluid.layers.fill_constant( + shape=[1], value=0, dtype="int64") + + for i in range(self.iter_num): + fluid.layers.array_write(input, zero + i, tensor_array) + + self.out_var = fluid.layers.concat(tensor_array, axis=self.axis) else: - self.actual_axis = self.axis + self.program = paddle.static.Program() + with paddle.static.program_guard(self.program): + input = paddle.assign(self.x) + tensor_array = fluid.layers.create_array( + dtype='float32' + ) # Api create_array is not supported in paddle 2.0 yet. + zero = paddle.zeros(shape=[1], dtype="int64") - self.outputs = { - 'Out': np.concatenate( - (self.x0, self.x1, self.x2), axis=self.actual_axis) - } + for i in range(self.iter_num): + # Api array_write is not supported in paddle 2.0 yet. + fluid.layers.array_write(input, zero + i, tensor_array) + + self.out_var = paddle.concat(tensor_array, axis=self.axis) def set_npu(self): self.__class__.use_npu = True - self.__class__.no_need_check_grad = True - - def init_dtype(self): - self.dtype = np.float16 - def test_check_output(self): - self.check_output_with_place(self.place) - - def init_test_data(self): - self.x0 = np.random.random((1, 4, 50)).astype(self.dtype) - self.x1 = np.random.random((2, 4, 50)).astype(self.dtype) - self.x2 = np.random.random((3, 4, 50)).astype(self.dtype) - self.axis = 0 + def test_fluid_api(self): + self._run_static_mode(use_fluid_api=True) + + def test_paddle_api(self): + self._run_static_mode(use_fluid_api=False) + + def _run_static_mode(self, use_fluid_api): + self.set_program(use_fluid_api) + self.assertTrue(self.out_var.shape[self.axis] == -1) + exe = fluid.Executor(self.place) + res = exe.run(self.program, fetch_list=self.out_var) + self.assertTrue( + np.array_equal( + res[0], + np.concatenate( + [self.x] * self.iter_num, axis=self.axis))) if __name__ == '__main__': From fba355fbc04ee2cacbc527fbd5e52c25a721e53b Mon Sep 17 00:00:00 2001 From: wawltor Date: Tue, 12 Oct 2021 19:57:22 +0800 Subject: [PATCH 5/7] change the paddle.mm to matmul_v2 (#35770) * change the paddle.mm to matmul_v2 * update the code for the mm * update the document for the mm --- python/paddle/tensor/math.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/python/paddle/tensor/math.py b/python/paddle/tensor/math.py index 14a925ef3e285..f5f0b5ed0873c 100755 --- a/python/paddle/tensor/math.py +++ b/python/paddle/tensor/math.py @@ -923,8 +923,6 @@ def mm(input, mat2, name=None): nontransposed, the prepended or appended dimension :math:`1` will be removed after matrix multiplication. - This op does not support broadcasting. See paddle.matmul. - Args: input (Tensor): The input tensor which is a Tensor. mat2 (Tensor): The input tensor which is a Tensor. @@ -949,9 +947,7 @@ def mm(input, mat2, name=None): """ if in_dygraph_mode(): - out = _varbase_creator(dtype=input.dtype) - _C_ops.matmul(input, mat2, out) - return out + return _C_ops.matmul_v2(input, mat2) def __check_input(x, y): var_names = {'x': x, 'y': y} @@ -991,7 +987,7 @@ def __check_input(x, y): helper = LayerHelper('mm', **locals()) out = helper.create_variable_for_type_inference(dtype=input.dtype) helper.append_op( - type='matmul', inputs={'X': input, + type='matmul_v2', inputs={'X': input, 'Y': mat2}, outputs={'Out': out}) return out From 3e2dec5b837397d2e8ecc006e302512c26adba9c Mon Sep 17 00:00:00 2001 From: Zhang Zheng <32410583+ZzSean@users.noreply.github.com> Date: Tue, 12 Oct 2021 21:46:37 +0800 Subject: [PATCH 6/7] Change the input param of fusion op interface from pointer to tensor (#36349) --- .../operators/fused/cudnn_bn_add_relu_test.cc | 64 ++++--------- .../fused/cudnn_bn_stats_finalize.cu.h | 24 +++-- .../operators/fused/cudnn_norm_conv.cu.h | 94 +++++++++++++++---- .../operators/fused/cudnn_norm_conv_test.cc | 61 ++++-------- .../fused/cudnn_scale_bias_add_relu.cu.h | 40 ++++++-- 5 files changed, 161 insertions(+), 122 deletions(-) diff --git a/paddle/fluid/operators/fused/cudnn_bn_add_relu_test.cc b/paddle/fluid/operators/fused/cudnn_bn_add_relu_test.cc index 837bca6c2cf4e..709d69214c603 100644 --- a/paddle/fluid/operators/fused/cudnn_bn_add_relu_test.cc +++ b/paddle/fluid/operators/fused/cudnn_bn_add_relu_test.cc @@ -536,32 +536,20 @@ class CudnnBNAddReluTester { bn_bias->Resize({1, 1, 1, channels_}); // input - float *sum_ptr = sum->data(); - float *sum_of_square_ptr = sum_of_square->data(); - float *bn_scale_ptr = bn_scale->data(); - float *bn_bias_ptr = bn_bias->data(); - mean->Resize({1, 1, 1, channels_}); var->Resize({1, 1, 1, channels_}); // output - float *mean_ptr = mean->data(); - float *var_ptr = var->data(); - float *saved_mean_ptr = - saved_mean->mutable_data({1, 1, 1, channels_}, place); - float *saved_var_ptr = - saved_var->mutable_data({1, 1, 1, channels_}, place); - T *equiv_scale_ptr = - equiv_scale->mutable_data({1, 1, 1, channels_}, place); - T *equiv_bias_ptr = - equiv_bias->mutable_data({1, 1, 1, channels_}, place); + equiv_scale->Resize({1, 1, 1, channels_}); + equiv_bias->Resize({1, 1, 1, channels_}); + saved_mean->Resize({1, 1, 1, channels_}); + saved_var->Resize({1, 1, 1, channels_}); auto param_shape = framework::vectorize(bn_scale->dims()); op::CudnnBNStatsFinalize bn_op(ctx, param_shape); - bn_op.Forward(ctx, sum_ptr, sum_of_square_ptr, bn_scale_ptr, bn_bias_ptr, - saved_mean_ptr, saved_var_ptr, mean_ptr, var_ptr, - equiv_scale_ptr, equiv_bias_ptr, eps_, momentum_, ele_count_, - true); + bn_op.Forward(ctx, *sum, *sum_of_square, *bn_scale, *bn_bias, saved_mean, + saved_var, mean, var, equiv_scale, equiv_bias, eps_, + momentum_, ele_count_, true); } // Get forward results of CudnnBNStatsFinalize + CudnnScaleBiasAddRelu @@ -627,21 +615,13 @@ class CudnnBNAddReluTester { &saved_var_z, &equiv_scale_z, &equiv_bias_z); } - T *x_ptr = x.data(); - T *z_ptr = (fuse_add_ || has_shortcut_) ? z.data() : nullptr; - T *equiv_scale_x_ptr = equiv_scale_x.data(); - T *equiv_bias_x_ptr = equiv_bias_x.data(); - T *equiv_scale_z_ptr = has_shortcut_ ? equiv_scale_z.data() : nullptr; - T *equiv_bias_z_ptr = has_shortcut_ ? equiv_bias_z.data() : nullptr; - T *y_ptr = - y.mutable_data({batch_size_, height_, width_, channels_}, place); + y.Resize(framework::make_ddim({batch_size_, height_, width_, channels_})); int c = channels_; int64_t nhw = ele_count_; int32_t c_int32_elems = ((c + 63) & ~63) / 32; int32_t nhw_int32_elems = (nhw + 31) & ~31; - int32_t *bitmask_ptr = bitmask.mutable_data( - {nhw_int32_elems, c_int32_elems, 1}, place); + bitmask.Resize(framework::make_ddim({nhw_int32_elems, c_int32_elems, 1})); auto data_shape = framework::vectorize(x.dims()); auto param_shape = framework::vectorize(bn_scale_x.dims()); @@ -651,8 +631,8 @@ class CudnnBNAddReluTester { op::CudnnScaleBiasAddRelu sbar_op(ctx, act_type_, fuse_add_, has_shortcut_, data_shape, param_shape, bitmask_shape); - sbar_op.Forward(ctx, x_ptr, equiv_scale_x_ptr, equiv_bias_x_ptr, y_ptr, - bitmask_ptr, z_ptr, equiv_scale_z_ptr, equiv_bias_z_ptr); + sbar_op.Forward(ctx, x, equiv_scale_x, equiv_bias_x, z, equiv_scale_z, + equiv_bias_z, &y, &bitmask); TensorCopySync(mean_x, platform::CPUPlace(), cpu_mean_x); TensorCopySync(var_x, platform::CPUPlace(), cpu_var_x); @@ -697,19 +677,10 @@ class CudnnBNAddReluTester { saved_mean.Resize({1, 1, 1, channels_}); saved_var.Resize({1, 1, 1, channels_}); - T *dy_ptr = dy.data(); - T *x_ptr = x.data(); - float *bn_scale_ptr = bn_scale.data(); - float *bn_bias_ptr = bn_bias.data(); - float *saved_mean_ptr = saved_mean.data(); - float *saved_var_ptr = saved_var.data(); - int32_t *bitmask_ptr = bitmask.data(); - T *dx_ptr = - dx.mutable_data({batch_size_, height_, width_, channels_}, place); - T *dz_ptr = - dz.mutable_data({batch_size_, height_, width_, channels_}, place); - float *dscale_ptr = dscale.mutable_data({1, 1, 1, channels_}, place); - float *dbias_ptr = dbias.mutable_data({1, 1, 1, channels_}, place); + dx.Resize(framework::make_ddim({batch_size_, height_, width_, channels_})); + dz.Resize(framework::make_ddim({batch_size_, height_, width_, channels_})); + dscale.Resize(framework::make_ddim({1, 1, 1, channels_})); + dbias.Resize(framework::make_ddim({1, 1, 1, channels_})); auto data_shape = framework::vectorize(x.dims()); auto param_shape = framework::vectorize(bn_scale.dims()); @@ -718,9 +689,8 @@ class CudnnBNAddReluTester { std::string act_type = "relu"; op::CudnnScaleBiasAddRelu sbar_op(ctx, act_type, true, false, data_shape, param_shape, bitmask_shape); - sbar_op.Backward(ctx, dy_ptr, x_ptr, bn_scale_ptr, bn_bias_ptr, - saved_mean_ptr, saved_var_ptr, bitmask_ptr, dx_ptr, dz_ptr, - dscale_ptr, dbias_ptr, eps_); + sbar_op.Backward(ctx, dy, x, bn_scale, bn_bias, saved_mean, saved_var, + bitmask, &dx, &dz, &dscale, &dbias, eps_); TensorCopySync(dx, platform::CPUPlace(), cpu_dx); TensorCopySync(dz, platform::CPUPlace(), cpu_dz); diff --git a/paddle/fluid/operators/fused/cudnn_bn_stats_finalize.cu.h b/paddle/fluid/operators/fused/cudnn_bn_stats_finalize.cu.h index 7d4b24cd4fc3d..dc703f9a822b5 100644 --- a/paddle/fluid/operators/fused/cudnn_bn_stats_finalize.cu.h +++ b/paddle/fluid/operators/fused/cudnn_bn_stats_finalize.cu.h @@ -68,12 +68,13 @@ class CudnnBNStatsFinalize { } ~CudnnBNStatsFinalize() {} - void Forward(const platform::CUDADeviceContext &ctx, float *sum_ptr, - float *sum_of_squares_ptr, float *scale_ptr, float *bias_ptr, - float *saved_mean_ptr, float *saved_invstd_ptr, - float *running_mean_ptr, float *running_var_ptr, - T *equiv_scale_ptr, T *equiv_bias_ptr, double eps, - float momentum, int64_t ele_count, bool is_train) { + void Forward(const platform::CUDADeviceContext &ctx, const Tensor &sum, + const Tensor &sum_of_squares, const Tensor &scale, + const Tensor &bias, Tensor *saved_mean, Tensor *saved_invstd, + Tensor *running_mean, Tensor *running_var, Tensor *equiv_scale, + Tensor *equiv_bias, double eps, float momentum, + int64_t ele_count, bool is_train) { + auto place = ctx.GetPlace(); if (is_train) { TrainInit(ctx); } else { @@ -82,6 +83,17 @@ class CudnnBNStatsFinalize { auto &op = is_train ? train_op_ : inference_op_; // Set variant_param for both inference_op_ and train_op_ + float *sum_ptr = const_cast(sum.data()); + float *sum_of_squares_ptr = + const_cast(sum_of_squares.data()); + float *scale_ptr = const_cast(scale.data()); + float *bias_ptr = const_cast(bias.data()); + float *saved_mean_ptr = saved_mean->mutable_data(place); + float *saved_invstd_ptr = saved_invstd->mutable_data(place); + float *running_mean_ptr = running_mean->mutable_data(place); + float *running_var_ptr = running_var->mutable_data(place); + T *equiv_scale_ptr = equiv_scale->mutable_data(place); + T *equiv_bias_ptr = equiv_bias->mutable_data(place); op.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_SCALE, scale_ptr); op.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_BIAS, bias_ptr); op.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_RUNNING_MEAN, running_mean_ptr); diff --git a/paddle/fluid/operators/fused/cudnn_norm_conv.cu.h b/paddle/fluid/operators/fused/cudnn_norm_conv.cu.h index 1a73281cb8dc6..9b9328a5ca620 100644 --- a/paddle/fluid/operators/fused/cudnn_norm_conv.cu.h +++ b/paddle/fluid/operators/fused/cudnn_norm_conv.cu.h @@ -38,7 +38,8 @@ struct NormConvolutionArgs { compute_type = platform::CudnnDataType::type; } - void Set(const std::vector &input_shape, + void Set(const platform::CUDADeviceContext &ctx, + const std::vector &input_shape, const std::vector &filter_shape, const std::vector &output_shape, int padding, int stride, int dilation, int group) { @@ -61,12 +62,33 @@ struct NormConvolutionArgs { "The filter_shape is expected to store as nhwc, and " "h = w = 1 or 3. But recieved filter_shape is [%s].", framework::make_ddim(filter_shape))); + PADDLE_ENFORCE_EQ((filter_shape[0] % 32 == 0 && filter_shape[3] % 8 == 0), + true, + platform::errors::InvalidArgument( + "The input channel is expected to be multiple of 8, " + "and the output channel is expected to be multiple " + "of 32. But recieved input channel is %d, output " + "channel is %d.", + filter_shape[3], filter_shape[0])); PADDLE_ENFORCE_EQ( output_shape.size(), 4U, platform::errors::InvalidArgument( "The size of output_shape is expected to 4. But recieved " "filter_shape's size is %d, filter_shape is [%s].", output_shape.size(), framework::make_ddim(output_shape))); + is_support = IsSupport(ctx, filter_shape, stride, dilation, group); + PADDLE_ENFORCE_EQ( + is_support, true, + platform::errors::InvalidArgument( + "Current test is only supported in the platforms with " + "compatiblity greater than or equal to 70 and the kernel size " + "must be equal to 1 or 3. When the kernel size is 1, " + "the stride must be 1 if the compatiblity is equal to 70. " + "Besides, the dilation and group must be equal to 1. But recieved " + "compatiblity is %d, kernel size is %d, stride is %d, " + "dilation is %d, group is %d", + ctx.GetComputeCapability(), filter_shape[1], stride, dilation, + group)); for (size_t i = 0; i < input_shape.size(); ++i) { in_dims.push_back(input_shape[i]); @@ -89,6 +111,25 @@ struct NormConvolutionArgs { conv_desc.set(dtype, paddings, strides, dilations, false, group); } + bool IsSupport(const platform::CUDADeviceContext &ctx, + const std::vector &filter_shape, int stride, int dilation, + int group) { + int kernel_size = filter_shape[1]; + if (dilation != 1 || group != 1) { + return false; + } + if (ctx.GetComputeCapability() == 70) { + if ((kernel_size == 3) || ((kernel_size == 1) && (stride == 1))) { + return true; + } + } else if (ctx.GetComputeCapability() > 70) { + if ((kernel_size == 3) || (kernel_size == 1)) { + return true; + } + } + return false; + } + cudnnDataType_t dtype; cudnnTensorFormat_t format; cudnnDataType_t compute_type; @@ -104,6 +145,8 @@ struct NormConvolutionArgs { platform::TensorDescriptor out_desc; platform::TensorDescriptor out_stats_desc; platform::ConvolutionDescriptor conv_desc; + + bool is_support; }; template @@ -115,15 +158,16 @@ class CudnnNormConvolution { const std::vector &output_shape, const int &padding, const int &stride, const int &dilation, const int &group) { - args_.Set(input_shape, filter_shape, output_shape, padding, stride, + args_.Set(ctx, input_shape, filter_shape, output_shape, padding, stride, dilation, group); } ~CudnnNormConvolution() {} - void Forward(const platform::CUDADeviceContext &ctx, T *input_ptr, - T *filter_ptr, T *output_ptr, float *sum_ptr, - float *sum_of_squares_ptr) { + void Forward(const platform::CUDADeviceContext &ctx, const Tensor &input, + const Tensor &filter, Tensor *output, Tensor *sum, + Tensor *sum_of_squares) { auto cudnn_handle = ctx.cudnn_handle(); + auto place = ctx.GetPlace(); CudnnFusionOp *fwd_op = GetForwardOp(ctx); size_t workspace_size = RoundUp( @@ -132,12 +176,17 @@ class CudnnNormConvolution { // Set variant_param // input ptr + T *input_ptr = const_cast(input.data()); + T *filter_ptr = const_cast(filter.data()); fwd_op->SetOpVariantParamAttrPtr(CUDNN_PTR_XDATA, input_ptr); fwd_op->SetOpVariantParamAttrPtr(CUDNN_PTR_WDATA, filter_ptr); fwd_op->SetOpVariantParamAttrPtr( CUDNN_SCALAR_SIZE_T_WORKSPACE_SIZE_IN_BYTES, &workspace_size); // output ptr + T *output_ptr = output->mutable_data(place); + float *sum_ptr = sum->mutable_data(place); + float *sum_of_squares_ptr = sum_of_squares->mutable_data(place); fwd_op->SetOpVariantParamAttrPtr(CUDNN_PTR_YDATA, output_ptr); fwd_op->SetOpVariantParamAttrPtr(CUDNN_PTR_YSUM, sum_ptr); fwd_op->SetOpVariantParamAttrPtr(CUDNN_PTR_YSQSUM, sum_of_squares_ptr); @@ -209,28 +258,34 @@ class CudnnNormConvolutionGrad { const std::vector &output_shape, const int &padding, const int &stride, const int &dilation, const int &group) { - args_.Set(input_shape, filter_shape, output_shape, padding, stride, + args_.Set(ctx, input_shape, filter_shape, output_shape, padding, stride, dilation, group); dgrad_algo_ = CUDNN_CONVOLUTION_BWD_DATA_ALGO_1; } ~CudnnNormConvolutionGrad() {} - void Backward(const platform::CUDADeviceContext &ctx, T *input_ptr, - T *output_grad_ptr, T *filter_ptr, T *input_grad_ptr, - T *filter_grad_ptr, bool use_addto = false) { - if (filter_grad_ptr) { - BackwardFilter(ctx, input_ptr, output_grad_ptr, filter_ptr, - filter_grad_ptr); + void Backward(const platform::CUDADeviceContext &ctx, const Tensor &input, + const Tensor &filter, const Tensor &output_grad, + Tensor *input_grad, Tensor *filter_grad, + bool use_addto = false) { + auto place = ctx.GetPlace(); + T *input_ptr = const_cast(input.data()); + T *filter_ptr = const_cast(filter.data()); + T *output_grad_ptr = const_cast(output_grad.data()); + + if (filter_grad) { + T *filter_grad_ptr = filter_grad->mutable_data(place); + BackwardFilter(ctx, output_grad_ptr, input_ptr, filter_grad_ptr); } - if (input_grad_ptr) { - BackwardData(ctx, input_ptr, output_grad_ptr, filter_ptr, input_grad_ptr, - use_addto); + if (input_grad) { + T *input_grad_ptr = input_grad->mutable_data(place); + BackwardData(ctx, output_grad_ptr, filter_ptr, input_grad_ptr, use_addto); } } private: - void BackwardFilter(const platform::CUDADeviceContext &ctx, T *input_ptr, - T *output_grad_ptr, T *filter_ptr, T *filter_grad_ptr) { + void BackwardFilter(const platform::CUDADeviceContext &ctx, + T *output_grad_ptr, T *input_ptr, T *filter_grad_ptr) { auto cudnn_handle = ctx.cudnn_handle(); CudnnFusionOp *wgrad_op = GetBackwardFilterOp(ctx); @@ -255,9 +310,8 @@ class CudnnNormConvolutionGrad { workspace_size); } - void BackwardData(const platform::CUDADeviceContext &ctx, T *input_ptr, - T *output_grad_ptr, T *filter_ptr, T *input_grad_ptr, - bool use_addto = false) { + void BackwardData(const platform::CUDADeviceContext &ctx, T *output_grad_ptr, + T *filter_ptr, T *input_grad_ptr, bool use_addto = false) { auto cudnn_handle = ctx.cudnn_handle(); size_t workspace_size = GetWorkspaceSizeBwdData(ctx); diff --git a/paddle/fluid/operators/fused/cudnn_norm_conv_test.cc b/paddle/fluid/operators/fused/cudnn_norm_conv_test.cc index 4c14029b99c69..23983d447e478 100644 --- a/paddle/fluid/operators/fused/cudnn_norm_conv_test.cc +++ b/paddle/fluid/operators/fused/cudnn_norm_conv_test.cc @@ -229,15 +229,6 @@ class CudnnNormConvolutionTester { platform::DeviceContextPool::Instance().Get( platform::CUDAPlace(0))); - if (!Support(*ctx)) { - LOG(INFO) - << "Current test is only supported in the platforms with " - << "compatiblity greater than or equal to 70 and the kernel size " - << "must be equal to 1 or 3. Besides, when the kernel size is 1, " - << "the stride must be 1 if the compatiblity is equal to 70."; - return; - } - framework::Tensor cpu_output_base; framework::Tensor cpu_sum_base; framework::Tensor cpu_sum_of_square_base; @@ -325,14 +316,10 @@ class CudnnNormConvolutionTester { TensorCopySync(cpu_input_, place, &input); TensorCopySync(cpu_filter_nhwc_, place, &filter_nhwc); - T *input_ptr = input.data(); - T *filter_ptr = filter_nhwc.data(); - T *output_ptr = output.mutable_data( - {batch_size_, out_height_, out_width_, output_channels_}, place); - float *sum_ptr = - sum.mutable_data({1, 1, 1, output_channels_}, place); - float *sum_of_square_ptr = - sum_of_square.mutable_data({1, 1, 1, output_channels_}, place); + output.Resize(framework::make_ddim( + {batch_size_, out_height_, out_width_, output_channels_})); + sum.Resize(framework::make_ddim({1, 1, 1, output_channels_})); + sum_of_square.Resize(framework::make_ddim({1, 1, 1, output_channels_})); auto input_shape = framework::vectorize(input.dims()); auto filter_shape = framework::vectorize(filter_nhwc.dims()); @@ -340,8 +327,7 @@ class CudnnNormConvolutionTester { op::CudnnNormConvolution conv_op(ctx, input_shape, filter_shape, output_shape, padding_, stride_, dilation_, group_); - conv_op.Forward(ctx, input_ptr, filter_ptr, output_ptr, sum_ptr, - sum_of_square_ptr); + conv_op.Forward(ctx, input, filter_nhwc, &output, &sum, &sum_of_square); TensorCopySync(output, platform::CPUPlace(), cpu_output); TensorCopySync(sum, platform::CPUPlace(), cpu_sum); @@ -362,11 +348,8 @@ class CudnnNormConvolutionTester { TensorCopySync(cpu_filter_nhwc_, place, &filter_nhwc); TensorCopySync(cpu_output_grad_, place, &output_grad); - T *input_ptr = input.data(); - T *filter_ptr = filter_nhwc.data(); - T *output_grad_ptr = output_grad.data(); - T *input_grad_ptr = input_grad.mutable_data(input.dims(), place); - T *filter_grad_ptr = filter_grad.mutable_data(filter_nhwc.dims(), place); + input_grad.Resize(input.dims()); + filter_grad.Resize(filter_nhwc.dims()); auto input_shape = framework::vectorize(input.dims()); auto filter_shape = framework::vectorize(filter_nhwc.dims()); @@ -374,26 +357,13 @@ class CudnnNormConvolutionTester { op::CudnnNormConvolutionGrad conv_grad_op(ctx, input_shape, filter_shape, output_shape, padding_, stride_, dilation_, group_); - conv_grad_op.Backward(ctx, input_ptr, output_grad_ptr, filter_ptr, - input_grad_ptr, filter_grad_ptr); + conv_grad_op.Backward(ctx, input, filter_nhwc, output_grad, &input_grad, + &filter_grad); TensorCopySync(input_grad, platform::CPUPlace(), cpu_input_grad); TensorCopySync(filter_grad, platform::CPUPlace(), cpu_filter_grad); } - bool Support(const platform::CUDADeviceContext &ctx) { - if (ctx.GetComputeCapability() == 70) { - if ((kernel_size_ == 3) || ((kernel_size_ == 1) && (stride_ == 1))) { - return true; - } - } else if (ctx.GetComputeCapability() > 70) { - if ((kernel_size_ == 3) || (kernel_size_ == 1)) { - return true; - } - } - return false; - } - private: int batch_size_; int height_; @@ -477,6 +447,15 @@ TEST(CudnnNormConvFp16, K1S2O4) { CudnnNormConvolutionTester test( batch_size, height, width, input_channels, output_channels, kernel_size, stride); - test.CheckForward(1e-3, true); - test.CheckBackward(1e-3); + platform::CUDADeviceContext *ctx = static_cast( + platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0))); + + if (ctx->GetComputeCapability() <= 70) { + ASSERT_THROW(test.CheckForward(1e-3, true), + paddle::platform::EnforceNotMet); + ASSERT_THROW(test.CheckBackward(1e-3), paddle::platform::EnforceNotMet); + } else { + ASSERT_NO_THROW(test.CheckForward(1e-3, true)); + ASSERT_NO_THROW(test.CheckBackward(1e-3)); + } } diff --git a/paddle/fluid/operators/fused/cudnn_scale_bias_add_relu.cu.h b/paddle/fluid/operators/fused/cudnn_scale_bias_add_relu.cu.h index 2fdb3635e2e14..b48c964d264ad 100644 --- a/paddle/fluid/operators/fused/cudnn_scale_bias_add_relu.cu.h +++ b/paddle/fluid/operators/fused/cudnn_scale_bias_add_relu.cu.h @@ -107,25 +107,33 @@ class CudnnScaleBiasAddRelu { ~CudnnScaleBiasAddRelu() {} - void Forward(const platform::CUDADeviceContext &ctx, T *x_ptr, T *x_scale_ptr, - T *x_bias_ptr, T *out_ptr, int32_t *bitmask_ptr, - T *z_ptr = nullptr, T *z_scale_ptr = nullptr, - T *z_bias_ptr = nullptr) { + void Forward(const platform::CUDADeviceContext &ctx, const Tensor &x, + const Tensor &x_scale, const Tensor &x_bias, const Tensor &z, + const Tensor &z_scale, const Tensor &z_bias, Tensor *out, + Tensor *bitmask) { ForwardInit(ctx); auto handle = ctx.cudnn_handle(); + auto place = ctx.GetPlace(); auto workspace_handle = ctx.cudnn_workspace_handle(); fwd_workspace_byte_ = fwd_op_.GetWorkspaceSizeInBytes(handle); // Set variant_param // input ptr + T *x_ptr = const_cast(x.data()); + T *x_scale_ptr = const_cast(x_scale.data()); + T *x_bias_ptr = const_cast(x_bias.data()); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_XDATA, x_ptr); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_EQSCALE, x_scale_ptr); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_EQBIAS, x_bias_ptr); if (has_shortcut_) { + T *z_ptr = const_cast(z.data()); + T *z_scale_ptr = const_cast(z_scale.data()); + T *z_bias_ptr = const_cast(z_bias.data()); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_ZDATA, z_ptr); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_Z_EQSCALE, z_scale_ptr); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_Z_EQBIAS, z_bias_ptr); } else { if (fused_add_) { + T *z_ptr = const_cast(z.data()); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_ZDATA, z_ptr); } } @@ -134,6 +142,8 @@ class CudnnScaleBiasAddRelu { CUDNN_SCALAR_SIZE_T_WORKSPACE_SIZE_IN_BYTES, &fwd_workspace_byte_); // output ptr + T *out_ptr = out->mutable_data(place); + int32_t *bitmask_ptr = bitmask->mutable_data(place); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_YDATA, out_ptr); fwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_ACTIVATION_BITMASK, bitmask_ptr); @@ -147,16 +157,30 @@ class CudnnScaleBiasAddRelu { fwd_workspace_byte_); } - void Backward(const platform::CUDADeviceContext &ctx, T *dy_ptr, T *x_ptr, - float *scale_ptr, float *bias_ptr, float *saved_mean_ptr, - float *saved_invstd_ptr, int32_t *bitmask_ptr, T *dx_ptr, - T *dz_ptr, float *dscale_ptr, float *dbias_ptr, double eps) { + void Backward(const platform::CUDADeviceContext &ctx, const Tensor &dy, + const Tensor &x, const Tensor &scale, const Tensor &bias, + const Tensor &saved_mean, const Tensor &saved_invstd, + const Tensor &bitmask, Tensor *dx, Tensor *dz, Tensor *dscale, + Tensor *dbias, double eps) { BackwardInit(ctx); auto handle = ctx.cudnn_handle(); + auto place = ctx.GetPlace(); auto workspace_handle = ctx.cudnn_workspace_handle(); bwd_workspace_byte_ = bwd_op_.GetWorkspaceSizeInBytes(handle); // Set variant_param // input ptr + T *dy_ptr = const_cast(dy.data()); + T *x_ptr = const_cast(x.data()); + float *scale_ptr = const_cast(scale.data()); + float *bias_ptr = const_cast(bias.data()); + float *saved_mean_ptr = const_cast(saved_mean.data()); + float *saved_invstd_ptr = const_cast(saved_invstd.data()); + int32_t *bitmask_ptr = const_cast(bitmask.data()); + T *dx_ptr = dx->mutable_data(place); + T *dz_ptr = dz ? dz->mutable_data(place) : nullptr; + float *dscale_ptr = dscale ? dscale->mutable_data(place) : nullptr; + float *dbias_ptr = dbias ? dbias->mutable_data(place) : nullptr; + bwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_XDATA, x_ptr); bwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_DYDATA, dy_ptr); bwd_op_.SetOpVariantParamAttrPtr(CUDNN_PTR_BN_SCALE, scale_ptr); From 033a73c376eef67c8f7da91e713b94982d1b477a Mon Sep 17 00:00:00 2001 From: Zeng Jinle <32832641+sneaxiy@users.noreply.github.com> Date: Tue, 12 Oct 2021 22:00:10 +0800 Subject: [PATCH 7/7] Revert "refine LarsOptimizer (#36351)" (#36369) This reverts commit b3f6eedb77925c28a193eaedb858220b9417c5ca. --- python/paddle/fluid/optimizer.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/python/paddle/fluid/optimizer.py b/python/paddle/fluid/optimizer.py index 4625d7ea89b25..24076e82b0365 100755 --- a/python/paddle/fluid/optimizer.py +++ b/python/paddle/fluid/optimizer.py @@ -2047,15 +2047,11 @@ def _create_accumulators(self, block, parameters): def _append_optimize_op(self, block, param_and_grad): assert isinstance(block, framework.Block) _lars_weight_decay = self._lars_weight_decay - _lars_coeff = self._lars_coeff param_name = param_and_grad[0].name - is_excluded = False if len(self._exclude_from_weight_decay) > 0: for name in self._exclude_from_weight_decay: if name in param_name: _lars_weight_decay = 0.0 - _lars_coeff = 0.0 - is_excluded = True break velocity_acc = self._get_accumulator(self._velocity_acc_str, @@ -2069,7 +2065,7 @@ def _append_optimize_op(self, block, param_and_grad): attrs = { "mu": self._momentum, - "lars_coeff": _lars_coeff, + "lars_coeff": self._lars_coeff, "lars_weight_decay": _lars_weight_decay, "multi_precision": find_master, "rescale_grad": self._rescale_grad @@ -2090,7 +2086,7 @@ def _append_optimize_op(self, block, param_and_grad): # create the momentum optimize op momentum_op = block.append_op( - type='momentum' if is_excluded else self.type, + type=self.type, inputs=inputs, outputs=outputs, attrs=attrs,