From 7a323f78aa6c343412532ad4c7ac8f76653500ce Mon Sep 17 00:00:00 2001
From: huangjiyi <43315610+huangjiyi@users.noreply.github.com>
Date: Wed, 19 Apr 2023 10:39:12 +0800
Subject: [PATCH] update (#53033)

---
 .../operators/sequence_ops/sequence_pad_op.cc | 27 ++++++++++++-------
 .../operators/sequence_ops/sequence_pad_op.cu | 26 +++++++++++-------
 .../operators/sequence_ops/sequence_pad_op.h  |  5 ++--
 .../sequence_ops/sequence_pool_op.cc          |  9 ++++---
 .../sequence_ops/sequence_pool_op.cu          |  4 +--
 .../operators/sequence_ops/sequence_pool_op.h |  2 +-
 .../sequence_ops/sequence_reshape_op.cc       | 26 +++++++++++-------
 .../sequence_ops/sequence_reshape_op.cu       | 27 +++++++++++--------
 .../sequence_ops/sequence_reshape_op.h        |  4 +--
 .../sequence_ops/sequence_reverse_op.cc       | 15 ++++++-----
 .../sequence_ops/sequence_reverse_op.cu       | 16 ++++++-----
 .../sequence_ops/sequence_reverse_op.h        |  2 +-
 .../sequence_ops/sequence_scatter_op.cc       | 26 +++++++++++-------
 .../sequence_ops/sequence_scatter_op.h        |  4 +--
 .../sequence_ops/sequence_slice_op.cc         | 27 +++++++++++--------
 .../sequence_ops/sequence_slice_op.cu         | 27 +++++++++++--------
 .../sequence_ops/sequence_slice_op.h          |  4 +--
 17 files changed, 149 insertions(+), 102 deletions(-)

diff --git a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc
index b99ece05176..c00354dbc64 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc
@@ -285,13 +285,20 @@ REGISTER_OPERATOR(sequence_pad,
 REGISTER_OPERATOR(sequence_pad_grad,
                   ops::SequencePadGradOp,
                   ops::SequencePadGradOpNoNeedBufferVarsInferer);
-REGISTER_OP_CPU_KERNEL(sequence_pad,
-                       ops::SequencePadOpKernel<phi::CPUContext, float>,
-                       ops::SequencePadOpKernel<phi::CPUContext, double>,
-                       ops::SequencePadOpKernel<phi::CPUContext, int>,
-                       ops::SequencePadOpKernel<phi::CPUContext, int64_t>);
-REGISTER_OP_CPU_KERNEL(sequence_pad_grad,
-                       ops::SequencePadGradOpKernel<phi::CPUContext, float>,
-                       ops::SequencePadGradOpKernel<phi::CPUContext, double>,
-                       ops::SequencePadGradOpKernel<phi::CPUContext, int>,
-                       ops::SequencePadGradOpKernel<phi::CPUContext, int64_t>);
+
+PD_REGISTER_STRUCT_KERNEL(sequence_pad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequencePadOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_pad_grad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequencePadGradOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cu b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cu
index 84a3e8da141..910a4eae21f 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cu
+++ b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cu
@@ -15,13 +15,19 @@ limitations under the License. */
 #include "paddle/fluid/operators/sequence_ops/sequence_pad_op.h"
 
 namespace ops = paddle::operators;
-REGISTER_OP_CUDA_KERNEL(sequence_pad,
-                        ops::SequencePadOpKernel<phi::GPUContext, float>,
-                        ops::SequencePadOpKernel<phi::GPUContext, double>,
-                        ops::SequencePadOpKernel<phi::GPUContext, int>,
-                        ops::SequencePadOpKernel<phi::GPUContext, int64_t>);
-REGISTER_OP_CUDA_KERNEL(sequence_pad_grad,
-                        ops::SequencePadGradOpKernel<phi::GPUContext, float>,
-                        ops::SequencePadGradOpKernel<phi::GPUContext, double>,
-                        ops::SequencePadGradOpKernel<phi::GPUContext, int>,
-                        ops::SequencePadGradOpKernel<phi::GPUContext, int64_t>);
+PD_REGISTER_STRUCT_KERNEL(sequence_pad,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequencePadOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_pad_grad,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequencePadGradOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_pad_op.h b/paddle/fluid/operators/sequence_ops/sequence_pad_op.h
index 50eddef1ce0..d31611b94a6 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pad_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_pad_op.h
@@ -25,8 +25,7 @@ namespace paddle {
 namespace operators {
 
 using LoD = framework::LoD;
-
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequencePadOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
@@ -68,7 +67,7 @@ class SequencePadOpKernel : public framework::OpKernel<T> {
   }
 };
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequencePadGradOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
diff --git a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc
index c44427f98f2..f51cc7d9036 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc
@@ -197,6 +197,9 @@ REGISTER_OPERATOR(sequence_pool_grad,
                   ops::SequencePoolGradOp,
                   ops::SequencePoolGradOpNoNeedBufferVarsInferer);
 
-REGISTER_OP_CPU_KERNEL(sequence_pool_grad,
-                       ops::SequencePoolGradKernel<phi::CPUContext, float>,
-                       ops::SequencePoolGradKernel<phi::CPUContext, double>);
+PD_REGISTER_STRUCT_KERNEL(sequence_pool_grad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequencePoolGradKernel,
+                          float,
+                          double) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cu b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cu
index df5dde79274..796b02cb03e 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cu
+++ b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cu
@@ -14,5 +14,5 @@ limitations under the License. */
 #include "paddle/fluid/operators/sequence_ops/sequence_pool_op.h"
 
 namespace ops = paddle::operators;
-REGISTER_OP_CUDA_KERNEL(sequence_pool_grad,
-                        ops::SequencePoolGradKernel<phi::GPUContext, float>);
+PD_REGISTER_STRUCT_KERNEL(
+    sequence_pool_grad, GPU, ALL_LAYOUT, ops::SequencePoolGradKernel, float) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_pool_op.h b/paddle/fluid/operators/sequence_ops/sequence_pool_op.h
index 7bf2d384508..7b00395bb6b 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_pool_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_pool_op.h
@@ -23,7 +23,7 @@ limitations under the License. */
 namespace paddle {
 namespace operators {
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequencePoolGradKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& context) const override {
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc
index 6925267f1a9..ff956ab2d1d 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc
@@ -144,13 +144,19 @@ REGISTER_OPERATOR(sequence_reshape,
                   ops::SequenceReshapeGradOpMaker<paddle::framework::OpDesc>,
                   ops::SequenceReshapeGradOpMaker<paddle::imperative::OpBase>);
 REGISTER_OPERATOR(sequence_reshape_grad, ops::SequenceReshapeGradOp);
-REGISTER_OP_CPU_KERNEL(sequence_reshape,
-                       ops::SequenceReshapeKernel<phi::CPUContext, float>,
-                       ops::SequenceReshapeKernel<phi::CPUContext, double>,
-                       ops::SequenceReshapeKernel<phi::CPUContext, int>,
-                       ops::SequenceReshapeKernel<phi::CPUContext, int64_t>);
-REGISTER_OP_CPU_KERNEL(sequence_reshape_grad,
-                       ops::SequenceReshapeGradKernel<phi::CPUContext, float>,
-                       ops::SequenceReshapeGradKernel<phi::CPUContext, double>,
-                       ops::SequenceReshapeGradKernel<phi::CPUContext, int64_t>,
-                       ops::SequenceReshapeGradKernel<phi::CPUContext, int>);
+PD_REGISTER_STRUCT_KERNEL(sequence_reshape,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReshapeKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_reshape_grad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReshapeGradKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cu b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cu
index eaf34643a07..2bca49f62c3 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cu
+++ b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cu
@@ -15,14 +15,19 @@ limitations under the License. */
 #include "paddle/fluid/operators/sequence_ops/sequence_reshape_op.h"
 
 namespace ops = paddle::operators;
-REGISTER_OP_CUDA_KERNEL(sequence_reshape,
-                        ops::SequenceReshapeKernel<phi::GPUContext, float>,
-                        ops::SequenceReshapeKernel<phi::GPUContext, double>,
-                        ops::SequenceReshapeKernel<phi::GPUContext, int>,
-                        ops::SequenceReshapeKernel<phi::GPUContext, int64_t>);
-REGISTER_OP_CUDA_KERNEL(
-    sequence_reshape_grad,
-    ops::SequenceReshapeGradKernel<phi::GPUContext, float>,
-    ops::SequenceReshapeGradKernel<phi::GPUContext, double>,
-    ops::SequenceReshapeGradKernel<phi::GPUContext, int64_t>,
-    ops::SequenceReshapeGradKernel<phi::GPUContext, int>);
+PD_REGISTER_STRUCT_KERNEL(sequence_reshape,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReshapeKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_reshape_grad,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReshapeGradKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.h b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.h
index 4c5bff7fc56..de530bed0d6 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.h
@@ -20,7 +20,7 @@ namespace paddle {
 namespace operators {
 
 using LoDTensor = phi::DenseTensor;
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequenceReshapeKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& context) const override {
@@ -85,7 +85,7 @@ class SequenceReshapeKernel : public framework::OpKernel<T> {
   }
 };
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequenceReshapeGradKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& context) const override {
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc
index d1e8409653a..2bc2c43da1a 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc
@@ -22,9 +22,12 @@ REGISTER_OPERATOR(sequence_reverse,
                   ops::SequenceReverseGradOpMaker<paddle::framework::OpDesc>,
                   ops::SequenceReverseGradOpMaker<paddle::imperative::OpBase>);
 
-REGISTER_OP_CPU_KERNEL(sequence_reverse,
-                       ops::SequenceReverseOpKernel<phi::CPUContext, uint8_t>,
-                       ops::SequenceReverseOpKernel<phi::CPUContext, int>,
-                       ops::SequenceReverseOpKernel<phi::CPUContext, int64_t>,
-                       ops::SequenceReverseOpKernel<phi::CPUContext, float>,
-                       ops::SequenceReverseOpKernel<phi::CPUContext, double>);
+PD_REGISTER_STRUCT_KERNEL(sequence_reverse,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReverseOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t,
+                          uint8_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cu b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cu
index 810130669b5..f016025fa06 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cu
+++ b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cu
@@ -15,10 +15,12 @@
 #include "paddle/fluid/operators/sequence_ops/sequence_reverse_op.h"
 
 namespace ops = paddle::operators;
-
-REGISTER_OP_CUDA_KERNEL(sequence_reverse,
-                        ops::SequenceReverseOpKernel<phi::GPUContext, uint8_t>,
-                        ops::SequenceReverseOpKernel<phi::GPUContext, int>,
-                        ops::SequenceReverseOpKernel<phi::GPUContext, int64_t>,
-                        ops::SequenceReverseOpKernel<phi::GPUContext, float>,
-                        ops::SequenceReverseOpKernel<phi::GPUContext, double>);
+PD_REGISTER_STRUCT_KERNEL(sequence_reverse,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequenceReverseOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t,
+                          uint8_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h
index 24e0ee2d11a..2236988025c 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h
@@ -111,7 +111,7 @@ struct SequenceReverseFunctor {
   size_t row_numel_;
 };
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequenceReverseOpKernel : public framework::OpKernel<T> {
   using LoDTensor = phi::DenseTensor;
 
diff --git a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc
index a626d487b53..cf7e549134c 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc
@@ -186,13 +186,19 @@ REGISTER_OPERATOR(sequence_scatter,
 REGISTER_OPERATOR(sequence_scatter_grad,
                   ops::SequenceScatterGradOp,
                   ops::SequenceScatterGradNoNeedBufferVarsInferer);
-REGISTER_OP_CPU_KERNEL(sequence_scatter,
-                       ops::SequenceScatterOpKernel<float>,
-                       ops::SequenceScatterOpKernel<double>,
-                       ops::SequenceScatterOpKernel<int>,
-                       ops::SequenceScatterOpKernel<int64_t>);
-REGISTER_OP_CPU_KERNEL(sequence_scatter_grad,
-                       ops::SequenceScatterGradientOpKernel<float>,
-                       ops::SequenceScatterGradientOpKernel<double>,
-                       ops::SequenceScatterGradientOpKernel<int>,
-                       ops::SequenceScatterGradientOpKernel<int64_t>);
+PD_REGISTER_STRUCT_KERNEL(sequence_scatter,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceScatterOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_scatter_grad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceScatterGradientOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.h b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.h
index 247b060d101..389b630015e 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.h
@@ -23,7 +23,7 @@ namespace operators {
 using Tensor = phi::DenseTensor;
 using LoDTensor = phi::DenseTensor;
 
-template <typename T>
+template <typename T, typename DeviceContext>
 class SequenceScatterOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
@@ -86,7 +86,7 @@ class SequenceScatterOpKernel : public framework::OpKernel<T> {
   }
 };
 
-template <typename T>
+template <typename T, typename DeviceContext>
 class SequenceScatterGradientOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
diff --git a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc
index b7e2ff766f0..ed6e53b9ca7 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc
+++ b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc
@@ -158,14 +158,19 @@ REGISTER_OPERATOR(sequence_slice,
 REGISTER_OPERATOR(sequence_slice_grad,
                   ops::SequenceSliceGradOp,
                   ops::SequenceSliceGradNoNeedBufferVarsInferer);
-REGISTER_OP_CPU_KERNEL(sequence_slice,
-                       ops::SequenceSliceOpKernel<phi::CPUContext, float>,
-                       ops::SequenceSliceOpKernel<phi::CPUContext, double>,
-                       ops::SequenceSliceOpKernel<phi::CPUContext, int>,
-                       ops::SequenceSliceOpKernel<phi::CPUContext, int64_t>);
-REGISTER_OP_CPU_KERNEL(
-    sequence_slice_grad,
-    ops::SequenceSliceGradOpKernel<phi::CPUContext, float>,
-    ops::SequenceSliceGradOpKernel<phi::CPUContext, double>,
-    ops::SequenceSliceGradOpKernel<phi::CPUContext, int>,
-    ops::SequenceSliceGradOpKernel<phi::CPUContext, int64_t>);
+PD_REGISTER_STRUCT_KERNEL(sequence_slice,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceSliceOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_slice_grad,
+                          CPU,
+                          ALL_LAYOUT,
+                          ops::SequenceSliceGradOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cu b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cu
index ecf39a07309..407eb2e3ad7 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cu
+++ b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cu
@@ -15,14 +15,19 @@ limitations under the License. */
 #include "paddle/fluid/operators/sequence_ops/sequence_slice_op.h"
 
 namespace ops = paddle::operators;
-REGISTER_OP_CUDA_KERNEL(sequence_slice,
-                        ops::SequenceSliceOpKernel<phi::GPUContext, float>,
-                        ops::SequenceSliceOpKernel<phi::GPUContext, double>,
-                        ops::SequenceSliceOpKernel<phi::GPUContext, int>,
-                        ops::SequenceSliceOpKernel<phi::GPUContext, int64_t>);
-REGISTER_OP_CUDA_KERNEL(
-    sequence_slice_grad,
-    ops::SequenceSliceGradOpKernel<phi::GPUContext, float>,
-    ops::SequenceSliceGradOpKernel<phi::GPUContext, double>,
-    ops::SequenceSliceGradOpKernel<phi::GPUContext, int>,
-    ops::SequenceSliceGradOpKernel<phi::GPUContext, int64_t>);
+PD_REGISTER_STRUCT_KERNEL(sequence_slice,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequenceSliceOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
+PD_REGISTER_STRUCT_KERNEL(sequence_slice_grad,
+                          GPU,
+                          ALL_LAYOUT,
+                          ops::SequenceSliceGradOpKernel,
+                          float,
+                          double,
+                          int,
+                          int64_t) {}
diff --git a/paddle/fluid/operators/sequence_ops/sequence_slice_op.h b/paddle/fluid/operators/sequence_ops/sequence_slice_op.h
index 205a743605c..19c074ef5f7 100644
--- a/paddle/fluid/operators/sequence_ops/sequence_slice_op.h
+++ b/paddle/fluid/operators/sequence_ops/sequence_slice_op.h
@@ -40,7 +40,7 @@ inline LoD SequenceSliceLoD(const T& in,
   return out_lod;
 }
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequenceSliceOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
@@ -151,7 +151,7 @@ class SequenceSliceOpKernel : public framework::OpKernel<T> {
   }
 };
 
-template <typename DeviceContext, typename T>
+template <typename T, typename DeviceContext>
 class SequenceSliceGradOpKernel : public framework::OpKernel<T> {
  public:
   void Compute(const framework::ExecutionContext& ctx) const override {
-- 
GitLab