format code

paddle/operators/math/unpooling.cc

@@ -20,8 +20,8 @@ template <typename T>
 class Unpool2dMaxFunctor<platform::CPUPlace, 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];

paddle/operators/math/unpooling.cu

@@ -20,11 +20,12 @@ namespace operators {
 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 channels, T* output_data,
-                                const int output_height,
-                                const int output_width) {
+                                  const int* indices_data,
+                                  const int input_height,
+                                  const int input_width,
+                                  const int channels, T* output_data,
+                                  const int output_height,
+                                  const int output_width) {
   int in_n_stride = input_height * input_width * channels;
   int in_c_stride = input_height * input_width;
   int out_n_stride = output_height * output_width * channels;
@@ -42,12 +43,11 @@ __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,
-                                const int output_width, T* input_grad) {
+__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;
   int out_n_stride = output_height * output_width * channels;
@@ -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];
@@ -88,8 +88,8 @@ class Unpool2dMaxFunctor<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_height, output_width);
+                             input_height, input_width, output_channels,
+                             output_data, output_height, output_width);
   }
 };
 /*
@@ -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

@@ -75,36 +75,38 @@ int OutputSize(int input_size, int ksize, int padding, int stride) {
 class UnpoolOp : public framework::OperatorWithKernel {
  protected:
   framework::OpKernelType GetKernelType(
-    const framework::ExecutionContext& ctx) const override {
-      return framework::OpKernelType(
-      framework::ToDataType(ctx.Input<framework::Tensor>("X")->type()),
+      const framework::ExecutionContext& ctx) const override {
+    return framework::OpKernelType(
+        framework::ToDataType(ctx.Input<framework::Tensor>("X")->type()),
         ctx.device_context());
-    }
+  }
 
  public:
   using framework::OperatorWithKernel::OperatorWithKernel;
   void InferShape(framework::InferShapeContext* ctx) const override {
-    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("X"),
+                   "Input(X) of UnpoolOp"
+                   "should not be null.");
+    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 =
         ctx->Attrs().Get<std::vector<int>>("paddings");
     PADDLE_ENFORCE(in_x_dims.size() == 4,
-                      "Unpooling intput must be of 4-dimensional.");
+                   "Unpooling intput must be of 4-dimensional.");
     PADDLE_ENFORCE_EQ(in_x_dims, in_y_dims);
     std::vector<int64_t> output_shape({in_x_dims[0], in_x_dims[1]});
     for (size_t i = 0; i < ksize.size(); ++i) {
       output_shape.push_back(
-        OutputSize(in_x_dims[i + 2], ksize[i], paddings[i], strides[i]));
+          OutputSize(in_x_dims[i + 2], ksize[i], paddings[i], strides[i]));
     }
     ctx->SetOutputDim("Out", framework::make_ddim(output_shape));
   }
@@ -113,30 +115,30 @@ class UnpoolOp : public framework::OperatorWithKernel {
 class UnpoolOpGrad : public framework::OperatorWithKernel {
  protected:
   framework::OpKernelType GetKernelType(
-    const framework::ExecutionContext& ctx) const override {
-      return framework::OpKernelType(
+      const framework::ExecutionContext& ctx) const override {
+    return framework::OpKernelType(
         framework::ToDataType(ctx.Input<framework::Tensor>("X")->type()),
         ctx.device_context());
-    }
+  }
 
  public:
   using framework::OperatorWithKernel::OperatorWithKernel;
   void InferShape(framework::InferShapeContext* ctx) const override {
     PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must not be null.");
     PADDLE_ENFORCE(ctx->HasOutput(framework::GradVarName("X")),
-                                  "Input(X@GRAD) should not be null.");
+                   "Input(X@GRAD) should not be null.");
     ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
   }
 };
-} // namespace operators
-} // namespace paddle
+}  // namespace operators
+}  // namespace paddle
 
 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>,
-    ops::UnpoolKernel<paddle::platform::CPUPlace, double>);
+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>,
     ops::UnpoolGradKernel<paddle::platform::CPUPlace, double>);

paddle/operators/unpool_op.cu.cc

@@ -15,9 +15,9 @@ 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>,
-    ops::UnpoolKernel<paddle::platform::GPUPlace, double>);
+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>,
     ops::UnpoolGradKernel<paddle::platform::GPUPlace, double>);