format code

paddle/operators/math/unpooling.cc

@@ -13,16 +13,14 @@ 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,
+ 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];
@@ -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,8 +81,7 @@ 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,
@@ -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,
+    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);
+              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,
+ 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,8 +31,7 @@ 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",
+    AddOutput("Out",
           "(Tensor) The output tensor of unpool operator."
           "The format of output tensor is also NCHW."
           "Where N is batch size, C is "
@@ -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>,
+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_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