diff --git a/paddle/fluid/operators/concat_op.h b/paddle/fluid/operators/concat_op.h index 6f4b9147c66e06d36a7ce7612ffd252ff7f7a21a..eceb68815e76854e47e3fe90f275aa2d9f96faae 100644 --- a/paddle/fluid/operators/concat_op.h +++ b/paddle/fluid/operators/concat_op.h @@ -47,13 +47,13 @@ static inline framework::DDim ComputeAndCheckShape( is_runtime || (out_dims[j] > 0 && inputs_dims[i][j] > 0); if (check_shape) { // check all shape in run time - PADDLE_ENFORCE_EQ( - inputs_dims[0][j], inputs_dims[i][j], - platform::errors::InvalidArgument( - "The shape of input[%d] must be equal to input[0]. " - "But received input[0]'s shape = " - "[%s], input[%d]'s shape = [%s].", - i, inputs_dims[0], i, inputs_dims[i])); + PADDLE_ENFORCE_EQ(inputs_dims[0][j], inputs_dims[i][j], + platform::errors::InvalidArgument( + "The %d-th dimension of input[0] and input[%d] " + "is expected to be equal." + "But received input[0]'s shape = " + "[%s], input[%d]'s shape = [%s].", + j, i, inputs_dims[0], i, inputs_dims[i])); } } } @@ -79,9 +79,9 @@ class ConcatKernel : public framework::OpKernel { void Compute(const framework::ExecutionContext& ctx) const override { auto ins = ctx.MultiInput("X"); framework::LoDTensor* out = ctx.Output("Out"); - PADDLE_ENFORCE_NOT_NULL( - ins[0], platform::errors::NotFound( - " The first input of concat should not be null.")); + PADDLE_ENFORCE_NOT_NULL(ins[0], + platform::errors::NotFound( + "The first input tensor is not initalized.")); auto axis = ctx.Attr("axis"); bool need_resize_out_dims = false; if (ctx.HasInput("AxisTensor")) { @@ -116,7 +116,9 @@ class ConcatKernel : public framework::OpKernel { platform::errors::Unimplemented( "The lod level of all input LoDTensors should be same. " "Maybe different lod level of input LoDTensors can concat," - " it is not supported currently.")); + "it is not supported currently. The lod level of %dth input " + "is %d and first input is %d.", + i, ins[i]->lod().size(), lod_size_0)); } else { lod_size = 0; break; @@ -181,9 +183,9 @@ class ConcatGradKernel : public framework::OpKernel { } } } - PADDLE_ENFORCE_NOT_NULL( - ins[0], platform::errors::NotFound( - "The first input of concat should not be null.")); + PADDLE_ENFORCE_NOT_NULL(ins[0], + platform::errors::NotFound( + "The first input tensor is not initalized.")); auto axis = ctx.Attr("axis"); if (ctx.HasInput("AxisTensor")) { diff --git a/paddle/fluid/operators/lod_reset_op.cc b/paddle/fluid/operators/lod_reset_op.cc index 66c6de45077645ba802684e5dd326f6761ffeb37..7adcc678f5c42b474fdd9271390dcf6e8d741541 100644 --- a/paddle/fluid/operators/lod_reset_op.cc +++ b/paddle/fluid/operators/lod_reset_op.cc @@ -32,9 +32,9 @@ class LoDResetOp : public framework::OperatorWithKernel { PADDLE_ENFORCE_GT( static_cast(level0.size()), 0, platform::errors::InvalidArgument( - "If Input(Y) not provided, the target lod should be " - "specified by attribute `target_lod`. But the size of " - "`target_lod` is 0.")); + "If Input(Y) is not provided, the output's LoD should be " + "specified by attribute 'target_lod'. But the size of " + "'target_lod' is 0.")); } else if (ctx->IsRuntime()) { ctx->ShareLoD("Y", "Out"); } diff --git a/paddle/fluid/operators/lod_reset_op.h b/paddle/fluid/operators/lod_reset_op.h index 8a809ece49b4139f9fe37b83ccd5eb2764b83607..1318bf2385c67892a32ea84304e10e4eada749c7 100644 --- a/paddle/fluid/operators/lod_reset_op.h +++ b/paddle/fluid/operators/lod_reset_op.h @@ -41,10 +41,10 @@ class LoDResetKernel : public framework::OpKernel { PADDLE_ENFORCE_EQ( static_cast(last_level.back()), in->dims()[0], platform::errors::InvalidArgument( - "The last value of `Y`'s last level LoD should be equal " - "to the first dimension of `X`. But received the last value of " - "`Y`'s last level LoD is %d, the first dimension of `X` is " - "%d. ", + "The last value of Input(Y)'s last level LoD should be equal " + "to the first dimension of Input(X). But received the last " + "value of Input(Y)'s last level LoD is %d, the first dimension " + "of Input(X) is %d.", static_cast(last_level.back()), in->dims()[0])); out->set_lod(y_lod); return; // early return, since lod already set @@ -75,19 +75,16 @@ class LoDResetKernel : public framework::OpKernel { PADDLE_ENFORCE_EQ( static_cast(level0.back()), in->dims()[0], platform::errors::InvalidArgument( - "The last value of `Target LoD`'s last level LoD should be equal " - "to the first dimension of `X`. But received the last value of " - "`Target LoD`'s last level LoD is %d, the first dimension of `X` " - "is " - "%d. ", - static_cast(level0.back()), in->dims()[0])); + "The last value of 'Target LoD''s last level LoD should be equal " + "to the first dimension of Input(X). But received the 'Target LoD' " + "is %s, Input(X)'s shape is is %s.", + framework::make_ddim(level0), in->dims())); for (size_t i = 0; i < level0.size() - 1; ++i) { - PADDLE_ENFORCE_GE( - level0[i + 1], level0[i], - platform::errors::InvalidArgument( - "Target LoD should be an ascending vector. But the %s element is " - "%s and the %s element of Target LoD is %s.", - i + 1, level0[i + 1], i, level0[i])); + PADDLE_ENFORCE_GE(level0[i + 1], level0[i], + platform::errors::InvalidArgument( + "'Target LoD' should be an ascending " + "vector. But received the Target LoD is %s.", + framework::make_ddim(level0))); } // cast level0 to size_t diff --git a/python/paddle/fluid/layers/nn.py b/python/paddle/fluid/layers/nn.py index ad9fcd537f2daa790a7fbcbeeb58a1a0ca09dc44..f4b7ec90cd5db6bac63f53ef4d503bd9e7f5b98f 100644 --- a/python/paddle/fluid/layers/nn.py +++ b/python/paddle/fluid/layers/nn.py @@ -6265,11 +6265,9 @@ def lod_reset(x, y=None, target_lod=None): helper = LayerHelper("lod_reset", **locals()) out = helper.create_variable_for_type_inference(dtype=x.dtype) if y is not None: - if y.lod_level > 0: - check_variable_and_dtype( - y, 'y', ['float32', 'float64', 'int32', 'int64'], 'lod_reset') - else: - check_variable_and_dtype(y, 'y', ['int32', 'int64'], 'lod_reset') + check_type(y, 'y', (Variable), 'lod_reset') + if y.lod_level == 0: + check_variable_and_dtype(y, 'y', ['int32'], 'lod_reset') helper.append_op( type="lod_reset", inputs={'X': x, 'Y': y}, outputs={'Out': out}) @@ -6327,6 +6325,9 @@ def lod_append(x, level): if (not isinstance(level, Iterable)) and (not isinstance(level, Variable)): raise ValueError("Input(level) must be list, tuple or Variable.") + check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'], + 'lod_append') + helper = LayerHelper("lod_append", **locals()) out = helper.create_variable_for_type_inference(dtype=x.dtype) @@ -6335,6 +6336,8 @@ def lod_append(x, level): if isinstance(level, Variable): inputs['Y'] = level + if level.lod_level == 0: + check_variable_and_dtype(level, 'level', ['int32'], 'lod_append') else: attrs['target_lod'] = level helper.append_op( diff --git a/python/paddle/fluid/tests/unittests/test_layers.py b/python/paddle/fluid/tests/unittests/test_layers.py index 4259fed5dd3477a69127a8044e33176311ae9a5b..1df1f34e761ce61d79542c1020f4a14062183424 100644 --- a/python/paddle/fluid/tests/unittests/test_layers.py +++ b/python/paddle/fluid/tests/unittests/test_layers.py @@ -3033,7 +3033,7 @@ class TestBook(LayerTest): z = layers.lod_reset(x=x, y=y) self.assertTrue(z.lod_level == 2) # case 2 - lod_tensor_in = layers.data(name='lod_in', shape=[1], dtype='int64') + lod_tensor_in = layers.data(name='lod_in', shape=[1], dtype='int32') z = layers.lod_reset(x=x, y=lod_tensor_in) self.assertTrue(z.lod_level == 1) # case 3 diff --git a/python/paddle/fluid/tests/unittests/test_lod_append_op.py b/python/paddle/fluid/tests/unittests/test_lod_append_op.py new file mode 100644 index 0000000000000000000000000000000000000000..a67ce8a897ce9c326b1da77770d50c379ae44f5d --- /dev/null +++ b/python/paddle/fluid/tests/unittests/test_lod_append_op.py @@ -0,0 +1,88 @@ +#Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. +# +# 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 +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# 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. + +from __future__ import print_function + +import unittest +import numpy as np +import paddle.fluid as fluid +import paddle.fluid.layers as layers +import paddle.fluid.core as core +from paddle.fluid import compiler, Program, program_guard +from paddle.fluid.op import Operator +from paddle.fluid.backward import append_backward + + +class TestLoDAppendAPI(unittest.TestCase): + def test_api(self, use_cuda=False): + main_program = Program() + with fluid.program_guard(main_program): + x = fluid.layers.data(name='x', shape=[6], dtype='float32') + result = fluid.layers.lod_append(x, [0, 2, 6]) + + x_i = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0]).astype("float32") + + for use_cuda in [False, True]: + if use_cuda and not fluid.core.is_compiled_with_cuda(): + return + place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() + exe = fluid.Executor(place) + [out] = exe.run(fluid.default_main_program(), + feed={'x': x_i}, + fetch_list=[result], + return_numpy=False) + self.assertEqual(out.recursive_sequence_lengths(), [[2, 4]]) + + +class TestLodAppendOpError(unittest.TestCase): + def test_errors(self): + with program_guard(Program()): + + def test_x_Variable(): + # The input(x) must be Variable. + x1 = np.array([0.9383, 0.1983, 3.2, 1.2]).astype("float64") + level1 = [0, 2, 4] + fluid.layers.lod_append(x1, level1) + self.assertRaises(TypeError, fluid.layers.lod_append, x1, + level1) + + def test_level_Variable(): + # The input(level) must be Variable or list. + x2 = fluid.layers.data(name='x2', shape=[4], dtype='float32') + level2 = 2 + fluid.layers.lod_append(x2, level2) + self.assertRaises(TypeError, fluid.layers.lod_append, x2, + level2) + + def test_x_dtype(): + for dtype in ["bool", "float16"]: + x3 = fluid.layers.data( + name='x3_' + dtype, shape=[4], dtype=dtype) + level3 = fluid.layers.data( + name='level3', shape=[4], dtype='int32', lod_level=2) + self.assertRaises(TypeError, fluid.layers.lod_append, x3, + level3) + + def test_level_dtype(): + for dtype in ["bool", "float16", "float32", "float64", "int64"]: + x4 = fluid.layers.data( + name='x4_' + dtype, shape=[4], dtype='float32') + level4 = fluid.layers.data( + name='level4', shape=[4], dtype=dtype, lod_level=0) + self.assertRaises(TypeError, fluid.layers.lod_append, x4, + level4) + + +if __name__ == "__main__": + unittest.main()