diff --git a/paddle/operators/math/CMakeLists.txt b/paddle/operators/math/CMakeLists.txt index 7b53d2a920556a5321410e0557768510c582bc30..e381545d272829d0c60a0992f35337b4b5c78a10 100644 --- a/paddle/operators/math/CMakeLists.txt +++ b/paddle/operators/math/CMakeLists.txt @@ -7,7 +7,7 @@ if(WITH_GPU) nv_library(cross_entropy SRCS cross_entropy.cc cross_entropy.cu DEPS operator) nv_library(pooling SRCS pooling.cc pooling.cu DEPS device_context) nv_library(vol2col SRCS vol2col.cc vol2col.cu DEPS device_context) - nv_library(sequence_project SRCS sequence_project.cc sequence_project.cu DEPS device_context) + nv_library(sequence_project SRCS sequence_project.cc sequence_project.cu DEPS device_context math_function) else() cc_library(math_function SRCS math_function.cc im2col.cc DEPS cblas device_context operator) cc_library(selected_rows_functor SRCS selected_rows_functor.cc DEPS selected_rows math_function) @@ -15,7 +15,7 @@ else() cc_library(cross_entropy SRCS cross_entropy.cc DEPS operator) cc_library(pooling SRCS pooling.cc DEPS device_context) cc_library(vol2col SRCS vol2col.cc DEPS device_context) - nv_library(sequence_project SRCS sequence_project.cc DEPS device_context) + cc_library(sequence_project SRCS sequence_project.cc DEPS device_context math_function) endif() cc_test(math_function_test SRCS math_function_test.cc DEPS math_function tensor) diff --git a/paddle/operators/math/sequence_project.h b/paddle/operators/math/sequence_project.h index aa9f6e289c4ff956eade0e5cf7b5cfc40296ff28..64a27d885dd6e733cb2194f3d0ed83f864a0b710 100644 --- a/paddle/operators/math/sequence_project.h +++ b/paddle/operators/math/sequence_project.h @@ -69,7 +69,7 @@ template class SequenceProjectFunctor { public: void operator()(const platform::DeviceContext& context, - const framework::LoDTensor*& in, + const framework::LoDTensor* in, const framework::LoDTensor* padding_data, framework::LoDTensor* col, bool padding_trainable, int context_start, int context_length, int context_stride, diff --git a/paddle/operators/sequence_conv_op.h b/paddle/operators/sequence_conv_op.h index d049e83ff352e09d1d98cf6a8b93d1331f75f2bf..a8bda2f046d0e7e4f92df0fceb28409dc3c6bf31 100644 --- a/paddle/operators/sequence_conv_op.h +++ b/paddle/operators/sequence_conv_op.h @@ -125,6 +125,7 @@ class SequenceConvGradKernel : public framework::OpKernel { auto temp = framework::EigenVector::Flatten(col); temp.device(context.GetEigenDevice()) = temp.constant(static_cast(0)); + math::matmul(context.device_context(), *out_g, false, *filter, true, T(1.0), &col, T(1.0)); } diff --git a/python/paddle/v2/framework/tests/test_seq_conv.py b/python/paddle/v2/framework/tests/test_seq_conv.py new file mode 100644 index 0000000000000000000000000000000000000000..32124d0a05986bbe19263cf66dfa489c73f26100 --- /dev/null +++ b/python/paddle/v2/framework/tests/test_seq_conv.py @@ -0,0 +1,239 @@ +import unittest +import numpy as np +import random +from op_test import OpTest + + +class TestSeqProject(OpTest): + def setUp(self): + self.init_test_case() + self.op_type = 'sequence_conv' + + if self.context_length == 1 \ + and self.context_start == 0 \ + and self.padding_trainable: + print "If context_start is 0 " \ + "and context_length is 1," \ + " padding_trainable should be false." + return + + # one level, batch size + x = np.random.uniform(0.1, 1, [self.input_size[0], + self.input_size[1]]).astype('float32') + + self.begin_pad = np.max([0, -self.context_start]) + self.end_pad = np.max([0, self.context_start + self.context_length - 1]) + self.total_pad = self.begin_pad + self.end_pad + if self.total_pad == 0: + self.total_pad = 1 + + # PaddingData mast be not empty. + # Otherwise(EnforceNotMet: enforce numel() > 0 failed, 0 <= 0) + padding_data = np.random.uniform( + 0.1, 1, [self.total_pad, self.input_size[1]]).astype('float32') + w = np.random.uniform( + 0.1, 1, [self.context_length, self.input_size[1]]).astype('float32') + self.inputs = { + 'X': (x, self.lod), + 'PaddingData': (padding_data, [[0, self.total_pad]]), + 'Filter': (w, [[0, self.context_length]]) + } + self.attrs = { + 'context_start': self.context_start, + 'context_length': self.context_length, + 'padding_trainable': self.padding_trainable, + 'context_stride': self.context_stride + } + out = np.zeros((self.input_size[0], 1)).astype('float32') + self.outputs = {'Out': out} + self.compute() + + def compute(self): + x, lod = self.inputs['X'] + filter = self.inputs['Filter'] + pading_data, _ = self.inputs['PaddingData'] + out = np.zeros((self.input_size[0], self.context_length * + self.input_size[1])).astype('float32') + lod = lod[0] + begin_pad = np.max([0, -self.context_start]) + + for i in range(len(lod) - 1): + for j in range(self.context_length): + in_begin = lod[i] + self.context_start + j + in_end = lod[i + 1] + self.context_start + j + out_begin = lod[i] + out_end = lod[i + 1] + if in_begin < lod[i]: + pad_size = np.min([lod[i] - in_begin, lod[i + 1] - lod[i]]) + if self.padding_trainable: + sub_w = pading_data[j:j + pad_size, :] + out[lod[i]:lod[i] + pad_size, j * self.input_size[1]:( + j + 1) * self.input_size[1]] = sub_w + out_begin = lod[i] + pad_size + in_begin = lod[i] + + if in_end > lod[i + 1]: + pad_size = np.min( + [in_end - lod[i + 1], lod[i + 1] - lod[i]]) + if self.padding_trainable: + sub_w = pading_data[begin_pad + self.context_start + j - + pad_size:begin_pad + + self.context_start + j, :] + out[lod[i + 1] - pad_size:lod[i + 1], j * self. + input_size[1]:(j + 1) * self.input_size[1]] = sub_w + in_end = lod[i + 1] + out_end = lod[i + 1] - pad_size + if in_end <= in_begin: + continue + + in_sub = x[in_begin:in_end, :] + out[out_begin:out_end, j * self.input_size[1]:(j + 1) * + self.input_size[1]] += in_sub + + filter_dim = filter[0].shape + output_dim = self.outputs['Out'].shape + filter[0].shape = filter_dim[0] * filter_dim[1] + self.outputs['Out'].shape = (output_dim[0], ) + np.dot(out, filter[0], out=self.outputs['Out']) + filter[0].shape = filter_dim + self.outputs['Out'].shape = output_dim + + def test_check_output(self): + self.check_output() + + def test_check_grad(self): + if self.padding_trainable: + self.check_grad( + set(['X', 'PaddingData', 'Filter']), + 'Out', + max_relative_error=0.05) + + def test_check_grad_input(self): + self.check_grad( + ['X'], + 'Out', + max_relative_error=0.05, + no_grad_set=set(['PaddingData', 'Filter'])) + + def test_check_grad_padding_data(self): + if self.padding_trainable: + self.check_grad( + ['PaddingData'], + 'Out', + max_relative_error=0.05, + no_grad_set=set(['X', 'Filter'])) + + def test_check_grad_Filter(self): + self.check_grad( + ['Filter'], + 'Out', + max_relative_error=0.05, + no_grad_set=set(['X', 'PaddingData'])) + + def init_test_case(self): + self.op_type = "sequence_project" + self.input_row = 11 + self.context_start = 0 + self.context_length = 1 + self.padding_trainable = False + self.context_stride = 1 + + self.input_size = [self.input_row, 23] + self.lod = [[0, 4, 5, 8, self.input_row]] + + +class TestSeqProjectCase1(TestSeqProject): + def init_test_case(self): + self.op_type = "sequence_project" + self.input_row = 11 + self.context_start = -1 + self.context_length = 3 + self.padding_trainable = True + self.context_stride = 1 + + self.input_size = [self.input_row, 23] + self.lod = [[0, 4, 5, 8, self.input_row]] + + +class TestSeqProjectCase2(TestSeqProject): + def init_test_case(self): + self.op_type = "sequence_project" + self.input_row = 25 + self.context_start = 2 + self.context_length = 3 + self.padding_trainable = True + self.context_stride = 1 + + self.input_size = [self.input_row, 23] + idx = range(self.input_size[0]) + del idx[0] + self.lod = [[0] + np.sort(random.sample(idx, 8)).tolist() + + [self.input_size[0]]] + + +''' +class TestSeqProjectCases(TestSeqProject): + def setUp(self): + self.init_test_case() + self.op_type = 'sequence_project' + + num = 0 + for context_start in [-5, -3, -1, 0, 3]: + for context_length in [1, 2, 5, 7]: + for batch_size in [1, 2, 5, 7]: + for padding_trainable in [False, True]: + + if context_length == 1 and context_start == 0 and padding_trainable: + continue + + self.context_start = context_start + self.context_length = context_length + self.padding_trainable = padding_trainable + self.input_size = [batch_size, 23] + x = np.random.uniform(0.1, 1, + self.input_size).astype('float32') + self.lod = [[0, self.input_size[0]]] + if self.input_size[0] > 2: + idx = range(self.input_size[0]) + del idx[0] + self.lod = [ + [0] + np.sort(random.sample(idx, 2)).tolist() + + [self.input_size[0]] + ] + + self.begin_pad = np.max([0, -self.context_start]) + self.end_pad = np.max([0, self.context_start + self.context_length - 1]) + self.total_pad = self.begin_pad + self.end_pad + if self.total_pad == 0: + self.total_pad = 1 + # PaddingData mast be not empty. Otherwise(EnforceNotMet: enforce numel() > 0 failed, 0 <= 0) + padding_data = np.random.uniform( + 0.1, 1, [self.total_pad, self.input_size[1]]).astype('float32') + + self.inputs = { + 'X': (x, self.lod), + 'PaddingData': (padding_data, [[0, self.total_pad]]) + } + self.attrs = { + 'context_start': self.context_start, + 'context_length': self.context_length, + 'padding_trainable': self.padding_trainable, + 'context_stride': self.context_stride + } + out = np.zeros((self.input_size[0], self.input_size[1] * + self.context_length)).astype('float32') + self.outputs = {'Out': out} + print num + print self.attrs + print batch_size + print padding_trainable + print "$$$$$$$$$$$$$" + + self.compute() + self.test_check_output() + + num += 1 +''' + +if __name__ == '__main__': + unittest.main()