undo base pooling

zjhellofss · Oct 21, 2023 · 928c6ba · 928c6ba
1 parent c2f2a70
commit 928c6ba
Show file tree

Hide file tree

Showing 6 changed files with 51 additions and 126 deletions.
diff --git a/source/layer/details/adaptive_avgpooling.cpp b/source/layer/details/adaptive_avgpooling.cpp
@@ -27,7 +27,7 @@
 namespace kuiper_infer {
 
 AdaptiveAveragePoolingLayer::AdaptiveAveragePoolingLayer(uint32_t output_h, uint32_t output_w)
-    : BasePoolingLayer("AdaptiveAveragePooling"), output_h_(output_h), output_w_(output_w) {
+    : NonParamLayer("AdaptiveAveragePooling"), output_h_(output_h), output_w_(output_w) {
   CHECK_GT(output_h_, 0);
   CHECK_GT(output_w_, 0);
 }
@@ -94,8 +94,27 @@ StatusCode AdaptiveAveragePoolingLayer::Forward(
            "incorrectly sized tensor "
         << i << "th";
 
-    ComputeOutput(input_data, output_data, input_h, input_w, input_c, pooling_h, pooling_w, 0, 0,
-                  stride_h, stride_w, PoolingType::kAveragePooling);
+    const uint32_t pooling_size = pooling_h * pooling_w;
+    for (uint32_t ic = 0; ic < input_c; ++ic) {
+      const arma::fmat& input_channel = input_data->slice(ic);
+      arma::fmat& output_channel = output_data->slice(ic);
+      for (uint32_t c = 0; c < input_w - pooling_w + 1; c += stride_w) {
+        uint32_t output_col = uint32_t(c / stride_w);
+        for (uint32_t r = 0; r < input_h - pooling_h + 1; r += stride_h) {
+          uint32_t output_row = uint32_t(r / stride_h);
+          float mean_value = 0.f;
+          float* output_channel_ptr = output_channel.colptr(output_col);
+          for (uint32_t w = 0; w < pooling_w; ++w) {
+            const float* col_ptr = input_channel.colptr(c + w) + r;
+            for (uint32_t h = 0; h < pooling_h; ++h) {
+              float current_value = *(col_ptr + h);
+              mean_value = mean_value + current_value;
+            }
+          }
+          *(output_channel_ptr + output_row) = mean_value / float(pooling_size);
+        }
+      }
+    }
   }
   return StatusCode::kSuccess;
 }

diff --git a/source/layer/details/adaptive_avgpooling.hpp b/source/layer/details/adaptive_avgpooling.hpp
@@ -23,10 +23,9 @@
 
 #ifndef KUIPER_INFER_SOURCE_LAYER_AVGPOOLING_HPP_
 #define KUIPER_INFER_SOURCE_LAYER_AVGPOOLING_HPP_
-#include "base_pooling.hpp"
 #include "layer/abstract/non_param_layer.hpp"
 namespace kuiper_infer {
-class AdaptiveAveragePoolingLayer : public BasePoolingLayer {
+class AdaptiveAveragePoolingLayer : public NonParamLayer {
  public:
   explicit AdaptiveAveragePoolingLayer(uint32_t output_h, uint32_t output_w);
 

diff --git a/source/layer/details/base_pooling.cpp b/source/layer/details/base_pooling.cpp
diff --git a/source/layer/details/base_pooling.hpp b/source/layer/details/base_pooling.hpp
diff --git a/source/layer/details/maxpooling.cpp b/source/layer/details/maxpooling.cpp
@@ -29,7 +29,7 @@ namespace kuiper_infer {
 
 MaxPoolingLayer::MaxPoolingLayer(uint32_t padding_h, uint32_t padding_w, uint32_t pooling_size_h,
                                  uint32_t pooling_size_w, uint32_t stride_h, uint32_t stride_w)
-    : BasePoolingLayer("MaxPooling"),
+    : NonParamLayer("MaxPooling"),
       padding_h_(padding_h),
       padding_w_(padding_w),
       pooling_size_h_(pooling_size_h),
@@ -108,8 +108,32 @@ StatusCode MaxPoolingLayer::Forward(const std::vector<std::shared_ptr<Tensor<flo
            "has an incorrectly sized tensor "
         << i << "th";
 
-    ComputeOutput(input_data, output_data, input_h, input_w, input_c, pooling_h, pooling_w,
-                  padding_h_, padding_w_, stride_h_, stride_w_, PoolingType::kMaxPooling);
+    for (uint32_t ic = 0; ic < input_c; ++ic) {
+      const arma::fmat& input_channel = input_data->slice(ic);
+      arma::fmat& output_channel = output_data->slice(ic);
+      for (uint32_t c = 0; c < input_padded_w - pooling_w + 1; c += stride_w_) {
+        uint32_t output_col = uint32_t(c / stride_w_);
+        for (uint32_t r = 0; r < input_padded_h - pooling_h + 1; r += stride_h_) {
+          uint32_t output_row = uint32_t(r / stride_h_);
+          float* output_channel_ptr = output_channel.colptr(output_col);
+          float max_value = std::numeric_limits<float>::lowest();
+          for (uint32_t w = 0; w < pooling_w; ++w) {
+            const float* col_ptr = input_channel.colptr(c + w - padding_w_);
+            for (uint32_t h = 0; h < pooling_h; ++h) {
+              float current_value = 0.f;
+              if ((h + r >= padding_h_ && w + c >= padding_w_) &&
+                  (h + r < input_h + padding_h_ && w + c < input_w + padding_w_)) {
+                current_value = *(col_ptr + r + h - padding_h_);
+              } else {
+                current_value = std::numeric_limits<float>::lowest();
+              }
+              max_value = std::max(max_value, current_value);
+            }
+          }
+          *(output_channel_ptr + output_row) = max_value;
+        }
+      }
+    }
   }
   return StatusCode::kSuccess;
 }

diff --git a/source/layer/details/maxpooling.hpp b/source/layer/details/maxpooling.hpp
@@ -23,10 +23,9 @@
 
 #ifndef KUIPER_INFER_SOURCE_LAYER_MAX_POOLING_
 #define KUIPER_INFER_SOURCE_LAYER_MAX_POOLING_
-#include "base_pooling.hpp"
 #include "layer/abstract/non_param_layer.hpp"
 namespace kuiper_infer {
-class MaxPoolingLayer : public BasePoolingLayer{
+class MaxPoolingLayer : public NonParamLayer {
  public:
   explicit MaxPoolingLayer(uint32_t padding_h, uint32_t padding_w, uint32_t pooling_size_h,
                            uint32_t pooling_size_w, uint32_t stride_h, uint32_t stride_w);