diff --git a/oneflow/core/functional/impl/math_functor.cpp b/oneflow/core/functional/impl/math_functor.cpp
index 40c6dcd2503..1d14c2c931e 100644
--- a/oneflow/core/functional/impl/math_functor.cpp
+++ b/oneflow/core/functional/impl/math_functor.cpp
@@ -1687,7 +1687,7 @@ class MovedimIntFunctor {
 
 class CumsumFunctor {
  public:
-  CumsumFunctor() { op_ = CHECK_JUST(one::OpBuilder("cumsum").Input("in").Output("out").Build()); }
+  CumsumFunctor() { op_ = CHECK_JUST(one::OpBuilder("cumsum").Input("x").Output("y").Build()); }
   Maybe<Tensor> operator()(const std::shared_ptr<one::Tensor>& input, int64_t dim) const {
     auto ndim = input->ndim();
     if (dim < 0) { dim += ndim; }
diff --git a/oneflow/ir/include/OneFlow/OneFlowUserOps.td b/oneflow/ir/include/OneFlow/OneFlowUserOps.td
index 9510552bfea..d0d96493ef6 100644
--- a/oneflow/ir/include/OneFlow/OneFlowUserOps.td
+++ b/oneflow/ir/include/OneFlow/OneFlowUserOps.td
@@ -3975,6 +3975,38 @@ def OneFlow_XlogyYGradOp : OneFlow_BaseOp<"xlogy_y_grad", [NoSideEffect, Declare
   let has_data_type_infer_fn = 1;
 }
 
+def OneFlow_CumsumOp : OneFlow_BaseOp<"cumsum", [NoSideEffect, DeclareOpInterfaceMethods<UserOpCompatibleInterface>]> {
+  let input = (ins
+    OneFlow_Tensor:$x
+  );
+  let output = (outs
+    OneFlow_Tensor:$y
+  );
+  let attrs = (ins
+    SI64Attr:$dim
+  );
+  let has_logical_tensor_desc_infer_fn = 1;
+  let has_physical_tensor_desc_infer_fn = 1;
+  let has_get_sbp_fn = 1;
+  let has_data_type_infer_fn = 1;
+}
+
+def OneFlow_CumsumGradOp : OneFlow_BaseOp<"cumsum_grad", [NoSideEffect, DeclareOpInterfaceMethods<UserOpCompatibleInterface>]> {
+  let input = (ins
+    OneFlow_Tensor:$dy
+  );
+  let output = (outs
+    OneFlow_Tensor:$dx
+  );
+  let attrs = (ins
+    SI64Attr:$dim
+  );
+  let has_logical_tensor_desc_infer_fn = 1;
+  let has_physical_tensor_desc_infer_fn = 1;
+  let has_get_sbp_fn = 1;
+  let has_data_type_infer_fn = 1;
+}
+
 #endif // GET_ONEFLOW_MATH_OP_DEFINITIONS
 
 // Group: MATMUL
diff --git a/oneflow/user/kernels/cumsum_kernel.cpp b/oneflow/user/kernels/cumsum_kernel.cpp
index bf923de2309..a783f6f3d1d 100644
--- a/oneflow/user/kernels/cumsum_kernel.cpp
+++ b/oneflow/user/kernels/cumsum_kernel.cpp
@@ -61,12 +61,12 @@ class CpuCumsumKernel final : public user_op::OpKernel {
 
  private:
   void Compute(user_op::KernelComputeContext* ctx) const override {
-    const auto* in = ctx->Tensor4ArgNameAndIndex("in", 0);
+    const auto* in = ctx->Tensor4ArgNameAndIndex("x", 0);
     auto elem_cnt = in->shape().elem_cnt();
     // judge whether tensor has 0 size dimension first
     if (!elem_cnt) { return; }
 
-    auto* out = ctx->Tensor4ArgNameAndIndex("out", 0);
+    auto* out = ctx->Tensor4ArgNameAndIndex("y", 0);
     auto dim = ctx->Attr<int64_t>("dim");
     const auto* in_ptr = in->dptr<T>();
     auto* out_ptr = out->mut_dptr<T>();
@@ -86,7 +86,7 @@ class CpuCumsumKernel final : public user_op::OpKernel {
 #define REGISTER_CUMSUM_KERNEL(dtype)                                                   \
   REGISTER_USER_KERNEL("cumsum").SetCreateFn<CpuCumsumKernel<dtype>>().SetIsMatchedHob( \
       (user_op::HobDeviceType() == DeviceType::kCPU)                                    \
-      && (user_op::HobDataType("out", 0) == GetDataType<dtype>::value));
+      && (user_op::HobDataType("y", 0) == GetDataType<dtype>::value));
 
 REGISTER_CUMSUM_KERNEL(int64_t)
 REGISTER_CUMSUM_KERNEL(float)
diff --git a/oneflow/user/kernels/cumsum_kernel.cu b/oneflow/user/kernels/cumsum_kernel.cu
index 2efae7027bb..8fdbf5a7f4e 100644
--- a/oneflow/user/kernels/cumsum_kernel.cu
+++ b/oneflow/user/kernels/cumsum_kernel.cu
@@ -120,11 +120,11 @@ class GpuCumsumKernel final : public user_op::OpKernel {
   using user_op::OpKernel::Compute;
   void Compute(user_op::KernelComputeContext* ctx) const override {
     // judge whether tensor has 0 size dimension first
-    const auto* in = ctx->Tensor4ArgNameAndIndex("in", 0);
+    const auto* in = ctx->Tensor4ArgNameAndIndex("x", 0);
     auto elem_cnt = in->shape().elem_cnt();
     if (!elem_cnt) { return; }
 
-    auto* out = ctx->Tensor4ArgNameAndIndex("out", 0);
+    auto* out = ctx->Tensor4ArgNameAndIndex("y", 0);
     auto dim = ctx->Attr<int64_t>("dim");
     const auto* in_ptr = in->dptr<T>();
     auto* out_ptr = out->mut_dptr<T>();
@@ -153,7 +153,7 @@ class GpuCumsumKernel final : public user_op::OpKernel {
 #define REGISTER_CUDA_CUMSUM_KERNEL(dtype)                                              \
   REGISTER_USER_KERNEL("cumsum").SetCreateFn<GpuCumsumKernel<dtype>>().SetIsMatchedHob( \
       (user_op::HobDeviceType() == DeviceType::kCUDA)                                   \
-      && (user_op::HobDataType("out", 0) == GetDataType<dtype>::value));
+      && (user_op::HobDataType("y", 0) == GetDataType<dtype>::value));
 
 REGISTER_CUDA_CUMSUM_KERNEL(int64_t)
 REGISTER_CUDA_CUMSUM_KERNEL(float)
diff --git a/oneflow/user/ops/cumsum_op.cpp b/oneflow/user/ops/cumsum_op.cpp
index beff8b29a5b..c72bd5937e0 100644
--- a/oneflow/user/ops/cumsum_op.cpp
+++ b/oneflow/user/ops/cumsum_op.cpp
@@ -14,74 +14,68 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 #include "oneflow/core/framework/framework.h"
+#include "oneflow/core/framework/op_generated.h"
 
 namespace oneflow {
 
-namespace {
+Maybe<void> CumsumOp::InferLogicalTensorDesc(user_op::InferContext* ctx) {
+  *ctx->OutputShape("y", 0) = ctx->InputShape("x", 0);
+  return Maybe<void>::Ok();
+}
 
-REGISTER_USER_OP("cumsum")
-    .Input("in")
-    .Output("out")
-    .Attr<int64_t>("dim")
-    .SetTensorDescInferFn([](user_op::InferContext* ctx) -> Maybe<void> {
-      *ctx->OutputShape("out", 0) = ctx->InputShape("in", 0);
-      return Maybe<void>::Ok();
-    })
-    .SetGetSbpFn([](user_op::SbpContext* ctx) -> Maybe<void> {
-      const auto& in_tensor_desc = ctx->LogicalTensorDesc4InputArgNameAndIndex("in", 0);
-      auto dim = ctx->Attr<int64_t>("dim");
-      for (auto i = dim + 1; i < in_tensor_desc.shape().NumAxes(); i++) {
-        ctx->NewBuilder()
-            .Split(user_op::OpArg("in", 0), i)
-            .Split(user_op::OpArg("out", 0), i)
-            .Build();
-      }
-      return Maybe<void>::Ok();
-    })
-    .SetDataTypeInferFn([](user_op::InferContext* ctx) -> Maybe<void> {
-      *ctx->OutputDType("out", 0) = ctx->InputDType("in", 0);
-      return Maybe<void>::Ok();
-    });
+Maybe<void> CumsumOp::InferPhysicalTensorDesc(user_op::InferContext* ctx) {
+  return InferLogicalTensorDesc(ctx);
+}
 
-REGISTER_USER_OP("cumsum_grad")
-    .Input("dy")
-    .Output("dx")
-    .Attr<int64_t>("dim")
-    .SetTensorDescInferFn([](user_op::InferContext* ctx) -> Maybe<void> {
-      *ctx->OutputShape("dx", 0) = ctx->InputShape("dy", 0);
-      return Maybe<void>::Ok();
-    })
-    .SetGetSbpFn([](user_op::SbpContext* ctx) -> Maybe<void> {
-      const auto& dy_tensor_desc = ctx->LogicalTensorDesc4InputArgNameAndIndex("dy", 0);
-      for (auto i = 0; i < dy_tensor_desc.shape().NumAxes(); i++) {
-        ctx->NewBuilder()
-            .Split(user_op::OpArg("dy", 0), i)
-            .Split(user_op::OpArg("dx", 0), i)
-            .Build();
-      }
-      return Maybe<void>::Ok();
-    })
-    .SetDataTypeInferFn([](user_op::InferContext* ctx) -> Maybe<void> {
-      *ctx->OutputDType("dx", 0) = ctx->InputDType("dy", 0);
-      return Maybe<void>::Ok();
-    });
+Maybe<void> CumsumOp::GetSbp(user_op::SbpContext* ctx) {
+  const auto& in_tensor_desc = ctx->LogicalTensorDesc4InputArgNameAndIndex("x", 0);
+  auto dim = ctx->Attr<int64_t>("dim");
+  for (auto i = dim + 1; i < in_tensor_desc.shape().NumAxes(); i++) {
+    ctx->NewBuilder().Split(user_op::OpArg("x", 0), i).Split(user_op::OpArg("y", 0), i).Build();
+  }
+  return Maybe<void>::Ok();
+}
+
+Maybe<void> CumsumOp::InferDataType(user_op::InferContext* ctx) {
+  *ctx->OutputDType("y", 0) = ctx->InputDType("x", 0);
+  return Maybe<void>::Ok();
+}
+
+Maybe<void> CumsumGradOp::InferLogicalTensorDesc(user_op::InferContext* ctx) {
+  *ctx->OutputShape("dx", 0) = ctx->InputShape("dy", 0);
+  return Maybe<void>::Ok();
+}
+
+Maybe<void> CumsumGradOp::InferPhysicalTensorDesc(user_op::InferContext* ctx) {
+  return InferLogicalTensorDesc(ctx);
+}
+
+Maybe<void> CumsumGradOp::GetSbp(user_op::SbpContext* ctx) {
+  const auto& dy_tensor_desc = ctx->LogicalTensorDesc4InputArgNameAndIndex("dy", 0);
+  for (auto i = 0; i < dy_tensor_desc.shape().NumAxes(); i++) {
+    ctx->NewBuilder().Split(user_op::OpArg("dy", 0), i).Split(user_op::OpArg("dx", 0), i).Build();
+  }
+  return Maybe<void>::Ok();
+}
+
+Maybe<void> CumsumGradOp::InferDataType(user_op::InferContext* ctx) {
+  *ctx->OutputDType("dx", 0) = ctx->InputDType("dy", 0);
+  return Maybe<void>::Ok();
+}
 
 REGISTER_USER_OP_GRAD("cumsum").SetGenBackwardOpConfFn(
     [](const user_op::UserOpWrapper& op, const user_op::AddOpFn& AddOp) -> Maybe<void> {
-      if (op.NeedGenGradTensor4OpInput("in", 0)) {
+      if (op.NeedGenGradTensor4OpInput("x", 0)) {
         user_op::UserOpConfWrapperBuilder builder(op.op_name() + "_grad");
-        user_op::UserOpConfWrapper grad_op =
-            builder.Op("cumsum_grad")
-                .Input("dy", op.GetGradTensorWithOpOutput("out", 0))
-                .Output("dx")
-                .Attr("dim", op.attr<int64_t>("dim"))
-                .Build();
+        user_op::UserOpConfWrapper grad_op = builder.Op("cumsum_grad")
+                                                 .Input("dy", op.GetGradTensorWithOpOutput("y", 0))
+                                                 .Output("dx")
+                                                 .Attr("dim", op.attr<int64_t>("dim"))
+                                                 .Build();
         op.BindGradTensorWithOpInput(grad_op.output("dx", 0), "x", 0);
         AddOp(grad_op);
       }
       return Maybe<void>::Ok();
     });
 
-}  // namespace
-
 }  // namespace oneflow