fix build error

lite/backends/arm/math/sequence_pool_grad.cc

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "lite/backends/arm/math/sequence_pool.h"
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
 #include "lite/backends/arm/math/funcs.h"
+#include "lite/backends/arm/math/sequence_pool_grad.h"
 #include "lite/core/op_registry.h"
 #include "lite/core/tensor.h"
 #include "lite/core/type_system.h"
@@ -28,7 +28,7 @@ namespace arm {
 namespace math {
 
 template <>
-void seq_pool_sum<float>(const float* din,
+void seq_pool_sum_grad<float>(const float* din,
                          const float* din_grad,
                          float* dout,
                          const std::vector<uint64_t> lod,
@@ -55,7 +55,7 @@ void seq_pool_sum<float>(const float* din,
 }
 
 template <>
-void seq_pool_average<float>(const float* din,
+void seq_pool_average_grad<float>(const float* din,
                              const float* din_grad,
                              float* dout,
                              const std::vector<uint64_t> lod,
@@ -85,7 +85,7 @@ void seq_pool_average<float>(const float* din,
 }
 
 template <>
-void seq_pool_sqrt<float>(const float* din,
+void seq_pool_sqrt_grad<float>(const float* din,
                           const float* din_grad,
                           float* dout,
                           const std::vector<uint64_t> lod,
@@ -115,7 +115,7 @@ void seq_pool_sqrt<float>(const float* din,
 }
 
 template <>
-void seq_pool_first<float>(const float* din,
+void seq_pool_first_grad<float>(const float* din,
                            const float* din_grad,
                            float* dout,
                            const std::vector<uint64_t> lod,

lite/backends/arm/math/sequence_pool_grad.h

@@ -28,6 +28,13 @@ void seq_pool_sum_grad(const T* din,
                   const std::vector<uint64_t> lod,
                   int64_t width);
 
+template <typename T>
+void seq_pool_average_grad(const T* din,
+                   const T* din_grad,
+                   T* dout,
+                   const std::vector<uint64_t> lod,
+                   int64_t width);
+
 template <typename T>
 void seq_pool_sqrt_grad(const T* din,
                    const T* din_grad,

lite/kernels/arm/sequence_pool_grad_compute.cc

@@ -57,13 +57,14 @@ void SequencePoolGradCompute::Run() {
 }  // namespace lite
 }  // namespace paddle
 
-REGISTER_LITE_KERNEL(sequence_pool,
+REGISTER_LITE_KERNEL(sequence_pool_grad,
                      kARM,
                      kFloat,
                      kNCHW,
-                     paddle::lite::kernels::arm::SequencePoolCompute,
+                     paddle::lite::kernels::arm::SequencePoolGradCompute,
                      def)
     .BindInput("X", {LiteType::GetTensorTy(TARGET(kARM))})
-    .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kARM))})
+    .BindInput("Out@GRAD", {LiteType::GetTensorTy(TARGET(kARM))})
+    .BindOutput("X@GRAD", {LiteType::GetTensorTy(TARGET(kARM))})
     .BindOutput("MaxIndex", {LiteType::GetTensorTy(TARGET(kARM))})
     .Finalize();

lite/operators/op_params.h

@@ -1012,13 +1012,13 @@ struct SequencePoolConcatParam : ParamBase {
 
 struct SequencePoolGradParam : ParamBase {
   const lite::Tensor* X{};
-  lite::Tensor* Out_Grad{};
   std::string pool_type{"AVERAGE"};
 #ifdef LITE_WITH_X86
   float pad_value{0.0};
   lite::Tensor* MaxIndex{};
 #endif
   // for backward
+  const lite::Tensor* Out_Grad{};
   lite::Tensor* X_Grad{};
 };
 

lite/operators/sequence_pool_grad_op.cc

@@ -19,7 +19,7 @@ namespace paddle {
 namespace lite {
 namespace operators {
 
-bool SequencePoolOp::CheckShape() const {
+bool SequencePoolGradOp::CheckShape() const {
   CHECK_OR_FALSE(param_.X);
   CHECK_OR_FALSE(param_.X_Grad);
   CHECK_OR_FALSE(param_.Out_Grad);
@@ -30,7 +30,7 @@ bool SequencePoolOp::CheckShape() const {
   return true;
 }
 
-bool SequencePoolOp::InferShapeImpl() const {
+bool SequencePoolGradOp::InferShapeImpl() const {
   const auto *input = param_.X;
   auto x_dims = input->dims();
   if (param_.X_Grad) {
@@ -40,18 +40,18 @@ bool SequencePoolOp::InferShapeImpl() const {
   return true;
 }
 
-bool SequencePoolOp::AttachImpl(const cpp::OpDesc &opdesc, lite::Scope *scope) {
+bool SequencePoolGradOp::AttachImpl(const cpp::OpDesc &opdesc, lite::Scope *scope) {
   param_.X = const_cast<lite::Tensor *>(
       &scope->FindVar(opdesc.Input("X").front())->Get<lite::Tensor>());
   CHECK(param_.X);
-  if (!op_desc.Input("Out@GRAD").empty()) {
-    auto *out_grad_var = scope->FindVar(op_desc.Input("Out@GRAD").front());
+  if (!opdesc.Input("Out@GRAD").empty()) {
+    auto *out_grad_var = scope->FindVar(opdesc.Input("Out@GRAD").front());
     CHECK(out_grad_var);
     param_.Out_Grad = &out_grad_var->Get<Tensor>();
   }
 
-  if (!op_desc.Output("X@GRAD").empty()) {
-    auto *x_grad_var = scope->FindVar(op_desc.Output("X@GRAD").front());
+  if (!opdesc.Output("X@GRAD").empty()) {
+    auto *x_grad_var = scope->FindVar(opdesc.Output("X@GRAD").front());
     CHECK(x_grad_var);
     param_.X_Grad = x_grad_var->GetMutable<Tensor>();
   }
@@ -63,4 +63,4 @@ bool SequencePoolOp::AttachImpl(const cpp::OpDesc &opdesc, lite::Scope *scope) {
 }  // namespace lite
 }  // namespace paddle
 
-REGISTER_LITE_OP(sequence_pool, paddle::lite::operators::SequencePoolOp);
+REGISTER_LITE_OP(sequence_pool_grad, paddle::lite::operators::SequencePoolGradOp);