format code

paddle/operators/math/unpooling.cc

@@ -13,17 +13,15 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #include "paddle/operators/math/unpooling.h"
-
 namespace paddle {
 namespace operators {
 namespace math {
-// All tensors are in NCHW format
 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) {
+ public:
+  void operator()(
+    const platform::DeviceContext& context, 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];
@@ -51,13 +49,11 @@ public:
 };
 template <class T>
 class Unpool2dMaxGradFunctor<platform::CPUPlace, T> {
-public:
-  void operator()(const platform::DeviceContext& context,
-                  const framework::Tensor& input,
-                  const framework::Tensor& indices,
-                  const framework::Tensor& output,
-                  const framework::Tensor& output_grad,
-                  framework::Tensor* input_grad) {
+ public:
+  void operator()(
+    const platform::DeviceContext& context, const framework::Tensor& input,
+    const framework::Tensor& indices, const framework::Tensor& output,
+    const framework::Tensor& output_grad, framework::Tensor* input_grad) {
     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

@@ -19,14 +19,10 @@ namespace paddle {
 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) {
+__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) {
   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;
@@ -44,16 +40,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;
@@ -75,11 +66,10 @@ __global__ void KernelUnpool2dMaxGrad(const int nthreads, const T* input_data,
  */
 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) {
+ public:
+  void operator()(
+    const platform::DeviceContext& context, 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];
@@ -91,12 +81,11 @@ public:
     T* output_data = output->mutable_data<T>(context.GetPlace());
     int threads = 1024;
     int grid = (input.numel() + threads - 1) / threads;
-    KernelUnpool2dMax<
-        T><<<grid, threads, 0,
+    KernelUnpool2dMax<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);
+             .stream()>>>(input.numel(), input_data, indices_data,
+                input_height, input_width, output_channels,
+                output_data, output_height, output_width);
   }
 };
 /*
@@ -104,7 +93,7 @@ public:
  */
 template <typename T>
 class Unpool2dMaxGradFunctor<platform::GPUPlace, T> {
-public:
+ public:
   void operator()(const platform::DeviceContext& context,
                   const framework::Tensor& input,
                   const framework::Tensor& indices,
@@ -124,13 +113,11 @@ public:
     T* input_grad_data = input_grad->mutable_data<T>(context.GetPlace());
     int threads = 1024;
     int grid = (input.numel() + threads - 1) / threads;
-    KernelUnpool2dMaxGrad<
-        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);
+    KernelUnpool2dMaxGrad<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);
   }
 };
 template class Unpool2dMaxGradFunctor<platform::GPUPlace, float>;

paddle/operators/math/unpooling.h

@@ -18,25 +18,20 @@ limitations under the License. */
 namespace paddle {
 namespace operators {
 namespace math {
-
 template <typename Place, typename T>
-
 class Unpool2dMaxFunctor {
-public:
-  void operator()(const platform::DeviceContext& context,
-                  const framework::Tensor& input,
-                  const framework::Tensor& indices, framework::Tensor* output);
+ public:
+  void operator()(
+    const platform::DeviceContext& context, const framework::Tensor& input,
+    const framework::Tensor& indices, framework::Tensor* output);
 };
-
 template <typename Place, class T>
 class Unpool2dMaxGradFunctor {
-public:
-  void operator()(const platform::DeviceContext& context,
-                  const framework::Tensor& input,
-                  const framework::Tensor& indices,
-                  const framework::Tensor& output,
-                  const framework::Tensor& output_grad,
-                  framework::Tensor* input_grad);
+ public:
+  void operator()(
+    const platform::DeviceContext& context, const framework::Tensor& input,
+    const framework::Tensor& indices, const framework::Tensor& output,
+    const framework::Tensor& output_grad, framework::Tensor* input_grad);
 };
 }  // namespace math
 }  // namespace operators

paddle/operators/unpool_op.cc

@@ -31,13 +31,12 @@ class Unpool2dOpMaker : public framework::OpProtoAndCheckerMaker {
         "(Tensor) The input tensor of the indices given out by MaxPool2d. "
         "The format of input tensor is NCHW. Where N is batch size, C is the "
         "number of channels, H and W is the height and width of feature.");
-    AddOutput(
-        "Out",
-        "(Tensor) The output tensor of unpool operator."
-        "The format of output tensor is also NCHW."
-        "Where N is batch size, C is "
-        "the number of channels, H and W is the height and "
-        "width of feature.");
+    AddOutput("Out",
+          "(Tensor) The output tensor of unpool operator."
+          "The format of output tensor is also NCHW."
+          "Where N is batch size, C is "
+          "the number of channels, H and W is the height and "
+          "width of feature.");
     AddAttr<std::vector<int>>(
         "ksize",
         "(vector), the unpooling window size(height, width) "
@@ -138,7 +137,7 @@ 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>,
+  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,11 +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_grad,
-                       ops::UnpoolGradKernel<paddle::platform::GPUPlace,
-                        float>,
-                       ops::UnpoolGradKernel<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>);

paddle/operators/unpool_op.h

@@ -20,7 +20,6 @@ limitations under the License. */
 
 namespace paddle {
 namespace operators {
-
 template <typename Place, typename T>
 class UnpoolKernel : public framework::OpKernel<T> {
  public:
@@ -41,7 +40,6 @@ class UnpoolKernel : public framework::OpKernel<T> {
     unpool2d_max_forward(context.device_context(), *in_x, *in_y, out);
   }
 };
-
 template <typename Place, typename T>
 class UnpoolGradKernel : public framework::OpKernel<T> {
  public:
@@ -69,6 +67,5 @@ class UnpoolGradKernel : public framework::OpKernel<T> {
                           *out_grad, in_x_grad);
   }
 };
-
 }  // namespace operators
 }  // namespace paddle