From 53185fde11cfd97fdd2f5c4787b3f7d1d6031461 Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Tue, 11 Sep 2018 11:55:51 +0800 Subject: [PATCH 1/6] Rewrite sequence pooling last and first mode with memcpy and clean code --- .../fluid/operators/math/sequence_pooling.cc | 43 +++++++++++++++++-- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index f25d3d3f1e..1ffbe3d820 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -103,6 +103,39 @@ class MaxSeqPoolGradFunctor { } }; +template +class LastFirstSeqPoolFunctor { + public: + void operator()(const platform::CPUDeviceContext& context, + const framework::LoDTensor& input, framework::Tensor* output, + const std::string pooltype) { + auto* in_data = input.data(); + auto* out_data = output->data(); + int64_t word_len = input.numel() / input.dims()[0]; + auto lod = input.lod()[0]; + auto dims = input.dims(); + if (pooltype == "LAST"){ + for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + in_data += seq_len* word_len; + std::memcpy(out_data,(in_data-word_len),word_len*sizeof(int)); + out_data += word_len; + + } + } + else if(pooltype == "FIRST"){ + for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + std::memcpy(out_data,in_data,word_len*sizeof(int)); + in_data += seq_len * word_len; + out_data += word_len; + + } + + } + } +}; + template class SequencePoolFunctor { public: @@ -116,6 +149,12 @@ class SequencePoolFunctor { max_pool(context, input, output, index); return; } + if (pooltype == "LAST" || pooltype == "FIRST") { + math::LastFirstSeqPoolFunctor lastfirst_pool; + lastfirst_pool(context, input, output, pooltype); + return; + } + auto lod = input.lod()[0]; auto& place = *context.eigen_device(); for (int i = 0; i < static_cast(lod.size()) - 1; ++i) { @@ -133,10 +172,6 @@ class SequencePoolFunctor { } else if (pooltype == "SQRT") { out_e.device(place) = in_e.sum(Eigen::array({{0}})) / std::sqrt(static_cast(h)); - } else if (pooltype == "LAST") { - out_e.device(place) = in_e.chip(h - 1, 0); - } else if (pooltype == "FIRST") { - out_e.device(place) = in_e.chip(0, 0); } else { PADDLE_THROW("unsupported pooling pooltype"); } From cdbc5e7353ff13a92a7f2ab59c784aa556926101 Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Tue, 11 Sep 2018 12:13:45 +0800 Subject: [PATCH 2/6] Add some comments --- paddle/fluid/operators/math/sequence_pooling.cc | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index 1ffbe3d820..f48c321c73 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -109,24 +109,32 @@ class LastFirstSeqPoolFunctor { void operator()(const platform::CPUDeviceContext& context, const framework::LoDTensor& input, framework::Tensor* output, const std::string pooltype) { + //Create pointers to input and output data auto* in_data = input.data(); auto* out_data = output->data(); + + //Calculate length of each word int64_t word_len = input.numel() / input.dims()[0]; auto lod = input.lod()[0]; - auto dims = input.dims(); if (pooltype == "LAST"){ for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + //Calculate the length of each sequence int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + //Point to the begin of next sequence in_data += seq_len* word_len; - std::memcpy(out_data,(in_data-word_len),word_len*sizeof(int)); + //Copy the last words to output + std::memcpy(out_data,(in_data-word_len),word_len*sizeof(T)); out_data += word_len; } } else if(pooltype == "FIRST"){ for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + //Calculate the length of each sequence int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - std::memcpy(out_data,in_data,word_len*sizeof(int)); + //Copy the first words of sequence to output + std::memcpy(out_data,in_data,word_len*sizeof(T)); + //Point to the next sequence in_data += seq_len * word_len; out_data += word_len; From 7429067ab3ea95b2f5564c568632bfa55d636f18 Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Tue, 11 Sep 2018 13:40:29 +0800 Subject: [PATCH 3/6] clean code --- .../fluid/operators/math/sequence_pooling.cc | 31 ++++++++++--------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index f48c321c73..ae63e47e94 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -113,34 +113,35 @@ class LastFirstSeqPoolFunctor { auto* in_data = input.data(); auto* out_data = output->data(); - //Calculate length of each word - int64_t word_len = input.numel() / input.dims()[0]; + //Calculate the size of each item in sequence + int64_t item_size = input.numel() / input.dims()[0]; auto lod = input.lod()[0]; + int seq_num = static_cast(lod.size()) - 1; if (pooltype == "LAST"){ - for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + for (int i=0; i < seq_num; ++i ){ //Calculate the length of each sequence int64_t seq_len = static_cast(lod[i + 1] - lod[i]); //Point to the begin of next sequence - in_data += seq_len* word_len; - //Copy the last words to output - std::memcpy(out_data,(in_data-word_len),word_len*sizeof(T)); - out_data += word_len; - + in_data += seq_len* item_size; + //Copy the last item to output + std::memcpy(out_data,(in_data-item_size),item_size*sizeof(T)); + out_data += item_size; } } else if(pooltype == "FIRST"){ - for (int i=0; i < static_cast(lod.size()) - 1; ++i ){ + for (int i=0; i < seq_num; ++i ){ //Calculate the length of each sequence int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - //Copy the first words of sequence to output - std::memcpy(out_data,in_data,word_len*sizeof(T)); + //Copy the first item of sequence to output + std::memcpy(out_data,in_data,item_size*sizeof(T)); //Point to the next sequence - in_data += seq_len * word_len; - out_data += word_len; - + in_data += seq_len * item_size; + out_data += item_size; } - } + else { + PADDLE_THROW("it's not LAST or FIRST pool type"); + } } }; From 1454cd54aa2ae9c672d5fcb8345457c6a9b8019b Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Tue, 11 Sep 2018 14:17:54 +0800 Subject: [PATCH 4/6] pre-commit check --- .../fluid/operators/math/sequence_pooling.cc | 64 +++++++++---------- 1 file changed, 31 insertions(+), 33 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index ae63e47e94..969a351d4f 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -109,40 +109,38 @@ class LastFirstSeqPoolFunctor { void operator()(const platform::CPUDeviceContext& context, const framework::LoDTensor& input, framework::Tensor* output, const std::string pooltype) { - //Create pointers to input and output data - auto* in_data = input.data(); - auto* out_data = output->data(); - - //Calculate the size of each item in sequence - int64_t item_size = input.numel() / input.dims()[0]; - auto lod = input.lod()[0]; - int seq_num = static_cast(lod.size()) - 1; - if (pooltype == "LAST"){ - for (int i=0; i < seq_num; ++i ){ - //Calculate the length of each sequence - int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - //Point to the begin of next sequence - in_data += seq_len* item_size; - //Copy the last item to output - std::memcpy(out_data,(in_data-item_size),item_size*sizeof(T)); - out_data += item_size; - } - } - else if(pooltype == "FIRST"){ - for (int i=0; i < seq_num; ++i ){ - //Calculate the length of each sequence - int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - //Copy the first item of sequence to output - std::memcpy(out_data,in_data,item_size*sizeof(T)); - //Point to the next sequence - in_data += seq_len * item_size; - out_data += item_size; - } - } - else { - PADDLE_THROW("it's not LAST or FIRST pool type"); + // Create pointers to input and output data + auto* in_data = input.data(); + auto* out_data = output->data(); + + // Calculate the size of each item in sequence + int64_t item_size = input.numel() / input.dims()[0]; + auto lod = input.lod()[0]; + int seq_num = static_cast(lod.size()) - 1; + if (pooltype == "LAST") { + for (int i = 0; i < seq_num; ++i) { + // Calculate the length of each sequence + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + // Point to the begin of next sequence + in_data += seq_len * item_size; + // Copy the last item of sequence to output + std::memcpy(out_data, (in_data - item_size), item_size * sizeof(T)); + out_data += item_size; } - } + } else if (pooltype == "FIRST") { + for (int i = 0; i < seq_num; ++i) { + // Calculate the length of each sequence + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + // Copy the first item of sequence to output + std::memcpy(out_data, in_data, item_size * sizeof(T)); + // Point to the next sequence + in_data += seq_len * item_size; + out_data += item_size; + } + } else { + PADDLE_THROW("it's not LAST or FIRST pool type"); + } + } }; template From 83394bab3e8e836d01acd78419193ff815d35467 Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Tue, 11 Sep 2018 16:59:33 +0800 Subject: [PATCH 5/6] modified by luotao's suggestion --- .../fluid/operators/math/sequence_pooling.cc | 72 +++++++++++-------- 1 file changed, 44 insertions(+), 28 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index 969a351d4f..f531cc058b 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -104,11 +104,10 @@ class MaxSeqPoolGradFunctor { }; template -class LastFirstSeqPoolFunctor { +class LastSeqPoolFunctor { public: void operator()(const platform::CPUDeviceContext& context, - const framework::LoDTensor& input, framework::Tensor* output, - const std::string pooltype) { + const framework::LoDTensor& input, framework::Tensor* output) { // Create pointers to input and output data auto* in_data = input.data(); auto* out_data = output->data(); @@ -117,29 +116,40 @@ class LastFirstSeqPoolFunctor { int64_t item_size = input.numel() / input.dims()[0]; auto lod = input.lod()[0]; int seq_num = static_cast(lod.size()) - 1; - if (pooltype == "LAST") { - for (int i = 0; i < seq_num; ++i) { - // Calculate the length of each sequence - int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - // Point to the begin of next sequence - in_data += seq_len * item_size; - // Copy the last item of sequence to output - std::memcpy(out_data, (in_data - item_size), item_size * sizeof(T)); - out_data += item_size; - } - } else if (pooltype == "FIRST") { - for (int i = 0; i < seq_num; ++i) { - // Calculate the length of each sequence - int64_t seq_len = static_cast(lod[i + 1] - lod[i]); - // Copy the first item of sequence to output - std::memcpy(out_data, in_data, item_size * sizeof(T)); - // Point to the next sequence - in_data += seq_len * item_size; - out_data += item_size; + for (int i = 0; i < seq_num; ++i) { + // Calculate the length of each sequence + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + // Point to the begin of next sequence + in_data += seq_len * item_size; + // Copy the last item of sequence to output + std::memcpy(out_data, (in_data - item_size), item_size * sizeof(T)); + out_data += item_size; + } + } +}; + +template +class FirstSeqPoolFunctor { + public: + void operator()(const platform::CPUDeviceContext& context, + const framework::LoDTensor& input, framework::Tensor* output) { + // Create pointers to input and output data + auto* in_data = input.data(); + auto* out_data = output->data(); + + // Calculate the size of each item in sequence + int64_t item_size = input.numel() / input.dims()[0]; + auto lod = input.lod()[0]; + int seq_num = static_cast(lod.size()) - 1; + for (int i = 0; i < seq_num; ++i) { + // Calculate the length of each sequence + int64_t seq_len = static_cast(lod[i + 1] - lod[i]); + // Copy the first item of sequence to output + std::memcpy(out_data, in_data, item_size * sizeof(T)); + // Point to the next sequence + in_data += seq_len * item_size; + out_data += item_size; } - } else { - PADDLE_THROW("it's not LAST or FIRST pool type"); - } } }; @@ -156,11 +166,17 @@ class SequencePoolFunctor { max_pool(context, input, output, index); return; } - if (pooltype == "LAST" || pooltype == "FIRST") { - math::LastFirstSeqPoolFunctor lastfirst_pool; - lastfirst_pool(context, input, output, pooltype); + if (pooltype == "LAST") { + math::LastSeqPoolFunctor last_pool; + last_pool(context, input, output); return; } + if (pooltype == "FIRST") { + math::FirstSeqPoolFunctor first_pool; + first_pool(context, input, output); + return; + } + auto lod = input.lod()[0]; auto& place = *context.eigen_device(); From 76553c5a6d198d731fd2331345684bc2cfdab881 Mon Sep 17 00:00:00 2001 From: bingyanghuang Date: Fri, 14 Sep 2018 16:01:38 +0800 Subject: [PATCH 6/6] fix travis-ci --- paddle/fluid/operators/math/sequence_pooling.cc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/paddle/fluid/operators/math/sequence_pooling.cc b/paddle/fluid/operators/math/sequence_pooling.cc index f531cc058b..69318a6598 100644 --- a/paddle/fluid/operators/math/sequence_pooling.cc +++ b/paddle/fluid/operators/math/sequence_pooling.cc @@ -107,7 +107,8 @@ template class LastSeqPoolFunctor { public: void operator()(const platform::CPUDeviceContext& context, - const framework::LoDTensor& input, framework::Tensor* output) { + const framework::LoDTensor& input, + framework::Tensor* output) { // Create pointers to input and output data auto* in_data = input.data(); auto* out_data = output->data(); @@ -124,7 +125,7 @@ class LastSeqPoolFunctor { // Copy the last item of sequence to output std::memcpy(out_data, (in_data - item_size), item_size * sizeof(T)); out_data += item_size; - } + } } }; @@ -132,7 +133,8 @@ template class FirstSeqPoolFunctor { public: void operator()(const platform::CPUDeviceContext& context, - const framework::LoDTensor& input, framework::Tensor* output) { + const framework::LoDTensor& input, + framework::Tensor* output) { // Create pointers to input and output data auto* in_data = input.data(); auto* out_data = output->data(); @@ -149,7 +151,7 @@ class FirstSeqPoolFunctor { // Point to the next sequence in_data += seq_len * item_size; out_data += item_size; - } + } } }; @@ -176,8 +178,6 @@ class SequencePoolFunctor { first_pool(context, input, output); return; } - - auto lod = input.lod()[0]; auto& place = *context.eigen_device(); for (int i = 0; i < static_cast(lod.size()) - 1; ++i) {