follow comments

paddle/gserver/layers/PoolProjection.cpp

@@ -18,6 +18,46 @@ namespace paddle {
 
 REGISTER_PROJECTION_CREATE_FUNC(pool, &PoolProjection::create);
 
+PoolProjection::PoolProjection(const ProjectionConfig& config,
+                               ParameterPtr parameter, bool useGpu)
+    : Projection(config, parameter, useGpu) {
+  const PoolConfig& conf = config_.pool_conf();
+  poolType_ = conf.pool_type();
+  channels_ = conf.channels();
+  sizeX_ = conf.size_x();
+  stride_ = conf.stride();
+  outputX_ = conf.output_x();
+  imgSize_ = conf.img_size();
+  confPadding_ = conf.padding();
+
+  sizeY_ = conf.has_size_y() ? conf.size_y() : conf.size_x();
+  imgSizeY_ = conf.has_img_size_y() ? conf.img_size_y() : conf.img_size();
+  strideY_ = conf.has_stride_y() ? conf.stride_y() : conf.stride();
+  confPaddingY_ = conf.has_padding_y() ? conf.padding_y() : conf.padding();
+  outputY_ = conf.has_output_y() ? conf.output_y() : conf.output_x();
+}
+
+size_t PoolProjection::getSize() {
+  imgSizeY_ = in_->getFrameHeight();
+  imgSize_ = in_->getFrameWidth();
+  const PoolConfig& conf = config_.pool_conf();
+  if (imgSizeY_ == 0) {
+    imgSizeY_ = conf.has_img_size_y() ? conf.img_size_y() : conf.img_size();
+  }
+  if (imgSize_ == 0) {
+    imgSize_ = conf.img_size();
+  }
+  outputY_ = outputSize(imgSizeY_, sizeY_, confPaddingY_, strideY_,
+                        /* caffeMode */ false);
+  outputX_ = outputSize(imgSize_, sizeX_, confPadding_, stride_,
+                        /* caffeMode */ false);
+
+  const_cast<Argument*>(out_)->setFrameHeight(outputY_);
+  const_cast<Argument*>(out_)->setFrameWidth(outputX_);
+
+  return outputY_ * outputX_ * channels_;
+}
+
 PoolProjection* PoolProjection::create(const ProjectionConfig& config,
                                        ParameterPtr parameter, bool useGpu) {
   const std::string& pool = config.pool_conf().pool_type();

paddle/gserver/layers/PoolProjection.h

@@ -31,46 +31,14 @@ protected:
 
 public:
   PoolProjection(const ProjectionConfig& config, ParameterPtr parameter,
-                 bool useGpu)
+                 bool useGpu);
-      : Projection(config, parameter, useGpu) {
-    const PoolConfig& conf = config_.pool_conf();
-    poolType_ = conf.pool_type();
-    channels_ = conf.channels();
-    sizeX_ = conf.size_x();
-    stride_ = conf.stride();
-    outputX_ = conf.output_x();
-    imgSize_ = conf.img_size();
-    confPadding_ = conf.padding();
 
-    sizeY_ = conf.has_size_y() ? conf.size_y() : conf.size_x();
-    imgSizeY_ = conf.has_img_size_y() ? conf.img_size_y() : conf.img_size();
-    strideY_ = conf.has_stride_y() ? conf.stride_y() : conf.stride();
-    confPaddingY_ = conf.has_padding_y() ? conf.padding_y() : conf.padding();
-    outputY_ = conf.has_output_y() ? conf.output_y() : conf.output_x();
-  }
   static PoolProjection* create(const ProjectionConfig& config,
                                 ParameterPtr parameter, bool useGpu);
-  const std::string& getPoolType() const { return poolType_; }
-  size_t getSize() {
-    imgSizeY_ = in_->getFrameHeight();
-    imgSize_ = in_->getFrameWidth();
-    const PoolConfig& conf = config_.pool_conf();
-    if (imgSizeY_ == 0) {
-      imgSizeY_ = conf.has_img_size_y() ? conf.img_size_y() : conf.img_size();
-    }
-    if (imgSize_ == 0) {
-      imgSize_ = conf.img_size();
-    }
-    outputY_ = outputSize(imgSizeY_, sizeY_, confPaddingY_, strideY_,
-                          /* caffeMode */ false);
-    outputX_ = outputSize(imgSize_, sizeX_, confPadding_, stride_,
-                          /* caffeMode */ false);
 
-    const_cast<Argument*>(out_)->setFrameHeight(outputY_);
+  const std::string& getPoolType() const { return poolType_; }
-    const_cast<Argument*>(out_)->setFrameWidth(outputX_);
 
-    return outputY_ * outputX_ * channels_;
+  size_t getSize();
-  }
 };
 
 class MaxPoolProjection : public PoolProjection {
@@ -78,6 +46,7 @@ public:
   MaxPoolProjection(const ProjectionConfig& config, ParameterPtr parameter,
                     bool useGpu)
       : PoolProjection(config, parameter, useGpu) {}
+
   virtual void forward();
   virtual void backward(const UpdateCallback& callback = nullptr);
 };
@@ -87,6 +56,7 @@ public:
   AvgPoolProjection(const ProjectionConfig& config, ParameterPtr parameter,
                     bool useGpu)
       : PoolProjection(config, parameter, useGpu) {}
+
   virtual void forward();
   virtual void backward(const UpdateCallback& callback = nullptr);
 };

paddle/gserver/layers/PoolProjectionLayer.h

@@ -12,13 +12,12 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License. */
 
-
 #pragma once
 
+#include <vector>
 #include "PoolLayer.h"
 #include "PoolProjection.h"
 #include "paddle/math/Matrix.h"
-#include <vector>
 
 namespace paddle {
 /**
@@ -32,15 +31,16 @@ protected:
   ProjectionConfig projectionConfig_;
 
 public:
-  size_t getSize();
+  explicit PoolProjectionLayer(const LayerConfig& config) : PoolLayer(config) {
-  virtual void forward(PassType passType);
-  virtual void backward(const UpdateCallback& callback = nullptr);
-  explicit PoolProjectionLayer(const LayerConfig& config)
-      : PoolLayer(config) {
     PoolConfig* conf = projectionConfig_.mutable_pool_conf();
     *conf = config_.inputs(0).pool_conf();
-    poolProjection_.reset(PoolProjection::create(projectionConfig_, nullptr,
+    poolProjection_.reset(
-                                                 useGpu_));
+        PoolProjection::create(projectionConfig_, nullptr, useGpu_));
   }
+
+  size_t getSize();
+
+  virtual void forward(PassType passType);
+  virtual void backward(const UpdateCallback& callback = nullptr);
 };
 }  // namespace paddle

paddle/gserver/layers/SpatialPyramidPoolLayer.h

@@ -12,15 +12,19 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License. */
 
-
 #pragma once
 
 #include "Layer.h"
 #include "PoolProjection.h"
-#include "paddle/utils/Logging.h"
 #include "paddle/math/MathUtils.h"
+#include "paddle/utils/Logging.h"
 
 namespace paddle {
+/**
+ * @brief A layer for spatial pyramid pooling on the input image by taking
+ * the max, average, etc. within regions, so that the result vector of
+ * different sized images are of the same size.
+ */
 
 class SpatialPyramidPoolLayer : public Layer {
 protected:
@@ -36,12 +40,15 @@ protected:
 
 public:
   explicit SpatialPyramidPoolLayer(const LayerConfig& config) : Layer(config) {}
+
   ~SpatialPyramidPoolLayer() {}
 
   virtual bool init(const LayerMap& layerMap, const ParameterMap& parameterMap);
+
   ProjectionConfig getConfig(size_t sizeX_, size_t sizeY_, size_t channels,
                              size_t pyamidLevel_, std::string& poolType_);
   size_t getSize();
+
   virtual void forward(PassType passType);
   virtual void backward(const UpdateCallback& callback = nullptr);
 };

python/paddle/trainer_config_helpers/tests/configs/protostr/test_spp_layer.protostr

@@ -0,0 +1,34 @@
+type: "nn"
+layers {
+  name: "data"
+  type: "data"
+  size: 3200
+  active_type: ""
+}
+layers {
+  name: "__spp_0__"
+  type: "spp"
+  size: 80
+  active_type: ""
+  inputs {
+    input_layer_name: "data"
+    spp_conf {
+      pool_type: "max-projection"
+      pyramid_height: 2
+      channels: 16
+      img_size: 10
+      img_size_y: 20
+    }
+  }
+}
+input_layer_names: "data"
+output_layer_names: "__spp_0__"
+sub_models {
+  name: "root"
+  layer_names: "data"
+  layer_names: "__spp_0__"
+  input_layer_names: "data"
+  output_layer_names: "__spp_0__"
+  is_recurrent_layer_group: false
+}
+

python/paddle/trainer_config_helpers/tests/configs/test_spp_layer.py

@@ -1,7 +1,7 @@
 from paddle.trainer_config_helpers import *
 
 settings(
-	  batch_size=100,
+    batch_size=100,
     learning_rate=1e-5
 )