format code

paddle/operators/math/unpooling.cu

@@ -21,7 +21,8 @@ namespace math {
 template <typename T>
 __global__ void KernelUnpool2dMax(const int nthreads, const T* input_data,
                                   const int* indices_data,
-                                const int input_height, const int input_width,
+                                  const int input_height,
+                                  const int input_width,
                                   const int channels, T* output_data,
                                   const int output_height,
                                   const int output_width) {
@@ -42,11 +43,10 @@ __global__ void KernelUnpool2dMax(const int nthreads, const T* input_data,
   }
 }
 template <typename T>
-__global__ void KernelUnpool2dMaxGrad(const int nthreads, const T* input_data,
-                                const int* indices_data,
-                                const int input_height, const int input_width,
-                                const int channels, const T* output_data,
-                                const T* output_grad, const int output_height,
+__global__ void KernelUnpool2dMaxGrad(
+    const int nthreads, const T* input_data, const int* indices_data,
+    const int input_height, const int input_width, const int channels,
+    const T* output_data, const T* output_grad, const int output_height,
     const int output_width, T* input_grad) {
   int in_n_stride = input_height * input_width * channels;
   int in_c_stride = input_height * input_width;
@@ -71,8 +71,8 @@ template <typename T>
 class Unpool2dMaxFunctor<platform::GPUPlace, T> {
  public:
   void operator()(const platform::DeviceContext& context,
-              const framework::Tensor& input, const framework::Tensor& indices,
-              framework::Tensor* output) {
+              const framework::Tensor& input,
+              const framework::Tensor& indices, framework::Tensor* output) {
     const int batch_size = input.dims()[0];
     const int input_height = input.dims()[2];
     const int input_width = input.dims()[3];
@@ -121,9 +121,9 @@ class Unpool2dMaxGradFunctor<platform::GPUPlace, T> {
         T><<<grid, threads, 0,
             reinterpret_cast<const platform::CUDADeviceContext&>(context)
                 .stream()>>>(input.numel(), input_data, indices_data,
-                    input_height, input_width, output_channels, output_data,
-                    output_grad_data, output_height, output_width,
-                    input_grad_data);
+                             input_height, input_width, output_channels,
+                             output_data, output_grad_data, output_height,
+                             output_width, input_grad_data);
   }
 };
 template class Unpool2dMaxGradFunctor<platform::GPUPlace, float>;

paddle/operators/math/unpooling.h

@@ -23,8 +23,7 @@ class Unpool2dMaxFunctor {
  public:
   void operator()(const platform::DeviceContext& context,
                   const framework::Tensor& input,
-                  const framework::Tensor& indices,
-                  framework::Tensor* output);
+                  const framework::Tensor& indices, framework::Tensor* output);
 };
 template <typename Place, class T>
 class Unpool2dMaxGradFunctor {

paddle/operators/unpool_op.cc

@@ -84,16 +84,18 @@ class UnpoolOp : public framework::OperatorWithKernel {
  public:
   using framework::OperatorWithKernel::OperatorWithKernel;
   void InferShape(framework::InferShapeContext* ctx) const override {
-    PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) of UnpoolOp"
+    PADDLE_ENFORCE(ctx->HasInput("X"),
+                   "Input(X) of UnpoolOp"
                    "should not be null.");
-    PADDLE_ENFORCE(ctx->HasInput("Indices"), "Input(Indices) of UnpoolOp"
+    PADDLE_ENFORCE(ctx->HasInput("Indices"),
+                   "Input(Indices) of UnpoolOp"
                    "should not be null.");
     PADDLE_ENFORCE(ctx->HasOutput("Out"),
                    "Output(Out) of UnpoolOp should not be null.");
     auto in_x_dims = ctx->GetInputDim("X");
     auto in_y_dims = ctx->GetInputDim("Indices");
-    std::string unpooling_type =
-        ctx->Attrs().Get<std::string>("unpooling_type");
+    std::string unpooling_type = ctx->Attrs()
+                                 .Get<std::string>("unpooling_type");
     std::vector<int> ksize = ctx->Attrs().Get<std::vector<int>>("ksize");
     std::vector<int> strides = ctx->Attrs().Get<std::vector<int>>("strides");
     std::vector<int> paddings =
@@ -134,8 +136,8 @@ class UnpoolOpGrad : public framework::OperatorWithKernel {
 namespace ops = paddle::operators;
 REGISTER_OP(unpool, ops::UnpoolOp, ops::Unpool2dOpMaker, unpool_grad,
             ops::UnpoolOpGrad);
-REGISTER_OP_CPU_KERNEL(
-    unpool, ops::UnpoolKernel<paddle::platform::CPUPlace, float>,
+REGISTER_OP_CPU_KERNEL(unpool,
+                       ops::UnpoolKernel<paddle::platform::CPUPlace, float>,
                        ops::UnpoolKernel<paddle::platform::CPUPlace, double>);
 REGISTER_OP_CPU_KERNEL(
     unpool_grad, ops::UnpoolGradKernel<paddle::platform::CPUPlace, float>,

paddle/operators/unpool_op.cu.cc

@@ -15,8 +15,8 @@ limitations under the License. */
 #include "paddle/operators/unpool_op.h"
 
 namespace ops = paddle::operators;
-REGISTER_OP_GPU_KERNEL(
-    unpool, ops::UnpoolKernel<paddle::platform::GPUPlace, float>,
+REGISTER_OP_GPU_KERNEL(unpool,
+                       ops::UnpoolKernel<paddle::platform::GPUPlace, float>,
                        ops::UnpoolKernel<paddle::platform::GPUPlace, double>);
 REGISTER_OP_GPU_KERNEL(
     unpool_grad, ops::UnpoolGradKernel<paddle::platform::GPUPlace, float>,