OpenI
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 15cca8f9d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '15cca8f9d6'
${ noResults }
MegEngine/dnn/test/arm_common/pooling.cpp

635 lines
25 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/arm_common/pooling.cpp

  3.  * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")

  4.  *

  5.  * Copyright (c) 2014-2020 Megvii Inc. All rights reserved.

  6.  *

  7.  * Unless required by applicable law or agreed to in writing,

  8.  * software distributed under the License is distributed on an

  9.  * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  10.  */

  11. #include "megdnn/dtype.h"

  12. #include "megdnn/opr_param_defs.h"

  13. #include "test/arm_common/fixture.h"

  14. 

  15. #include "test/common/pooling.h"

  16. #include "test/common/checker.h"

  17. #include "test/common/benchmarker.h"

  18. #include "test/common/rng.h"

  19. 

  20. namespace megdnn {

  21. namespace test {

  22. 

  23. TEST_F(ARM_COMMON, POOLING)

  24. {

  25.     using Param = param::Pooling;

  26.     // clang-format off

  27.     for (size_t ih: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  28.     for (size_t iw: {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  29.     for (size_t p: {1, 2})

  30.     {

  31.         Param param;

  32.         param.mode = Param::Mode::MAX;

  33.         param.window_h = param.window_w = 3;

  34.         param.stride_h = param.stride_w = 2;

  35.         param.pad_h = param.pad_w = p;

  36.         Checker<Pooling> checker(handle());

  37.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  38. 

  39.         param.mode = Param::Mode::AVERAGE;

  40.         param.window_h = param.window_w = 3;

  41.         param.stride_h = param.stride_w = 2;

  42.         param.pad_h = param.pad_w = p;

  43.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  44. 

  45.         param.mode = Param::Mode::MAX;

  46.         param.window_h = param.window_w = 4;

  47.         param.stride_h = param.stride_w = 2;

  48.         param.pad_h = param.pad_w = p;

  49.         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  50. 

  51.         param.mode = Param::Mode::MAX;

  52.         param.window_h = param.window_w = 5;

  53.         param.stride_h = param.stride_w = 2;

  54.         param.pad_h = param.pad_w = p;

  55.         if (ih + p * 2 >= 5 && iw + p * 2 >= 5)

  56.             checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  57.     }

  58.     // clang-format on

  59. }

  60. 

  61. TEST_F(ARM_COMMON, POOLING_INT8_W2x2_S2x2)

  62. {

  63.     // clang-format off

  64.     for (size_t ih: {2, 3, 7, 13, 52, 53, 54, 55})

  65.     for (size_t iw: {2, 3, 6, 14, 53, 54, 55, 56})

  66.     for (size_t ph: {0, 1})

  67.     for (size_t pw: {0, 1})

  68.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  69.     {

  70.         Checker<Pooling> checker(handle());

  71.         checker.set_dtype(0, dtype::Int8());

  72.         param::Pooling param;

  73.         param.mode = param::Pooling::Mode::MAX;

  74.         param.pad_h = ph;

  75.         param.pad_w = pw;

  76.         param.stride_h = param.stride_w = 2;

  77.         param.window_h = param.window_w = 2;

  78.         checker.set_param(param).exec(TensorShapeArray{{2, 3, ih, iw}, {}});

  79.     }

  80.     // clang-format on

  81. }

  82. 

  83. TEST_F(ARM_COMMON, POOLING_INT8_W3x3_S2x2)

  84. {

  85.     // clang-format off

  86.     for (size_t ih: {2, 3, 7, 13, 52, 53, 54, 55})

  87.     for (size_t iw: {2, 3, 6, 14, 53, 54, 55, 56})

  88.     for (size_t ph: {0, 1, 2})

  89.     for (size_t pw: {0, 1, 2})

  90.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  91.     {

  92.         Checker<Pooling> checker(handle());

  93.         checker.set_dtype(0, dtype::Int8());

  94.         param::Pooling param;

  95.         param.mode = param::Pooling::Mode::MAX;

  96.         param.pad_h = ph;

  97.         param.pad_w = pw;

  98.         param.stride_h = param.stride_w = 2;

  99.         param.window_h = param.window_w = 3;

  100.         checker.set_param(param).exec(TensorShapeArray{{2, 3, ih, iw}, {}});

  101.     }

  102.     // clang-format on

  103. }

  104. 

  105. TEST_F(ARM_COMMON, POOLING_MAX_W3x3_S2x2_NCHW44)

  106. {

  107.     // clang-format off

  108.     for (size_t ih: {3, 5, 10})

  109.     for (size_t iw: {3, 5, 7, 9, 15, 20})

  110.     for (size_t ph: {0})

  111.     for (size_t pw: {0})

  112.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  113.     {

  114.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  115.         Checker<Pooling> checker(handle());

  116.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  117.         checker.set_rng(0,&rng);

  118. 

  119.         param::Pooling param;

  120.         param.mode = param::Pooling::Mode::MAX;

  121.         param.format = param::Pooling::Format::NCHW44;

  122.         param.pad_h = ph;

  123.         param.pad_w = pw;

  124.         param.stride_h = param.stride_w = 2;

  125.         param.window_h = param.window_w = 3;

  126.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  127.     }

  128.     // clang-format on

  129. }

  130. 

  131. TEST_F(ARM_COMMON, POOLING_MAX_W3x3_S1x1_NCHW44)

  132. {

  133.     // clang-format off

  134.     for (size_t ih: {3, 5, 10})

  135.     for (size_t iw: {3, 5, 7, 9, 15, 20})

  136.     for (size_t ph: {0})

  137.     for (size_t pw: {0})

  138.     if (ih+2*ph >= 3 && iw+2*pw >= 3)

  139.     {

  140.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  141.         Checker<Pooling> checker(handle());

  142.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  143.         checker.set_rng(0,&rng);

  144. 

  145.         param::Pooling param;

  146.         param.mode = param::Pooling::Mode::MAX;

  147.         param.format = param::Pooling::Format::NCHW44;

  148.         param.pad_h = ph;

  149.         param.pad_w = pw;

  150.         param.stride_h = param.stride_w = 1;

  151.         param.window_h = param.window_w = 3;

  152.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  153.     }

  154.     // clang-format on

  155. }

  156. 

  157. TEST_F(ARM_COMMON, POOLING_MAX_W2x2_S1x1_NCHW44)

  158. {

  159.     // clang-format off

  160.     for (size_t ih: {2, 5, 10, 17})

  161.     for (size_t iw: {2, 6, 8, 16, 26})

  162.     for (size_t ph: {0})

  163.     for (size_t pw: {0})

  164.     if (ih+2*ph >= 2 && iw+2*pw >= 2)

  165.     {

  166.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  167.         Checker<Pooling> checker(handle());

  168.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  169.         checker.set_rng(0,&rng);

  170. 

  171.         param::Pooling param;

  172.         param.mode = param::Pooling::Mode::MAX;

  173.         param.format = param::Pooling::Format::NCHW44;

  174.         param.pad_h = ph;

  175.         param.pad_w = pw;

  176.         param.stride_h = param.stride_w = 1;

  177.         param.window_h = param.window_w = 2;

  178.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  179.     }

  180.     // clang-format on

  181. }

  182. TEST_F(ARM_COMMON, POOLING_MAX_W2x2_S2x2_NCHW44)

  183. {

  184.     // clang-format off

  185.     for (size_t ih: {2, 5, 10, 17})

  186.     for (size_t iw: {2, 6, 8, 16, 26})

  187.     for (size_t ph: {0})

  188.     for (size_t pw: {0})

  189.     if (ih+2*ph >= 2 && iw+2*pw >= 2)

  190.     {

  191.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  192.         Checker<Pooling> checker(handle());

  193.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  194.         checker.set_rng(0,&rng);

  195. 

  196.         param::Pooling param;

  197.         param.mode = param::Pooling::Mode::MAX;

  198.         param.format = param::Pooling::Format::NCHW44;

  199.         param.pad_h = ph;

  200.         param.pad_w = pw;

  201.         param.stride_h = param.stride_w = 2;

  202.         param.window_h = param.window_w = 2;

  203.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  204.     }

  205.     // clang-format on

  206. }

  207. TEST_F(ARM_COMMON, POOLING_MAX_W4x4_S1x1_NCHW44)

  208. {

  209.     // clang-format off

  210.     for (size_t ih: {4, 7, 10, 17, 20})

  211.     for (size_t iw: {4, 8, 10, 21, 32})

  212.     for (size_t ph: {0})

  213.     for (size_t pw: {0})

  214.     if (ih+2*ph >= 2 && iw+2*pw >= 2)

  215.     {

  216.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  217.         Checker<Pooling> checker(handle());

  218.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  219.         checker.set_rng(0,&rng);

  220. 

  221.         param::Pooling param;

  222.         param.mode = param::Pooling::Mode::MAX;

  223.         param.format = param::Pooling::Format::NCHW44;

  224.         param.pad_h = ph;

  225.         param.pad_w = pw;

  226.         param.stride_h = param.stride_w = 1;

  227.         param.window_h = param.window_w = 4;

  228.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  229.     }

  230.     // clang-format on

  231. }

  232. TEST_F(ARM_COMMON, POOLING_MAX_W4x4_S2x2_NCHW44)

  233. {

  234.     // clang-format off

  235.     for (size_t ih: {4, 10, 18, 25, 30})

  236.     for (size_t iw: {4, 12, 17, 20, 25})

  237.     for (size_t ph: {0})

  238.     for (size_t pw: {0})

  239.     if (ih+2*ph >= 2 && iw+2*pw >= 2)

  240.     {

  241.         UniformIntRNG rng{INT8_MIN >> 1, INT8_MAX >> 1};

  242.         Checker<Pooling> checker(handle());

  243.         checker.set_dtype(0, dtype::QuantizedS8(1.1f));

  244.         checker.set_rng(0,&rng);

  245. 

  246.         param::Pooling param;

  247.         param.mode = param::Pooling::Mode::MAX;

  248.         param.format = param::Pooling::Format::NCHW44;

  249.         param.pad_h = ph;

  250.         param.pad_w = pw;

  251.         param.stride_h = param.stride_w = 2;

  252.         param.window_h = param.window_w = 4;

  253.         checker.set_param(param).exec(TensorShapeArray{{2, 2, ih, iw, 4}, {}});

  254.     }

  255.     // clang-format on

  256. }

  257. 

  258. #if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

  259. TEST_F(ARM_COMMON, POOLING_FP16) {

  260.     Checker<Pooling> checker(handle());

  261.     checker.set_dtype(0, dtype::Float16{})

  262.             .set_dtype(1, dtype::Float16{})

  263.             .set_epsilon(3e-3);

  264. 

  265.     using Param = param::Pooling;

  266.     for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23})

  267.         for (size_t iw : {2, 3, 5, 7, 11, 13, 17, 19, 23})

  268.             for (auto mode : {Param::Mode::AVERAGE, Param::Mode::MAX}) {

  269.                 for (size_t window : {2, 3}) {

  270.                     Param param;

  271.                     param.mode = mode;

  272.                     param.window_h = param.window_w = window;

  273.                     param.stride_h = param.stride_w = 1;

  274.                     param.pad_h = param.pad_w = window / 2;

  275.                     //! test for SH == 1 && SW == 1 && FH == FW (FH == 2 || FH

  276.                     //! == 3)

  277.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  278. 

  279.                     //! test for SH = SW = 2 && FH = FW = 2

  280.                     param.stride_h = param.stride_w = 2;

  281.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  282.                 }

  283.             }

  284. 

  285.     //! test for SH == 2 && SW == 2 && FH == FW == 3 max pooling

  286.     for (size_t ih : {2, 3, 7, 13, 52, 53, 54, 55})

  287.         for (size_t iw : {2, 3, 6, 14, 53, 54, 55, 56})

  288.             for (size_t ph : {0, 1, 2})

  289.                 for (size_t pw : {0, 1, 2})

  290.                     if (ih + 2 * ph >= 3 && iw + 2 * pw >= 3) {

  291.                         param::Pooling param;

  292.                         param.mode = param::Pooling::Mode::MAX;

  293.                         param.pad_h = ph;

  294.                         param.pad_w = pw;

  295.                         param.stride_h = param.stride_w = 2;

  296.                         param.window_h = param.window_w = 3;

  297.                         checker.set_param(param).exec(

  298.                                 TensorShapeArray{{2, 3, ih, iw}, {}});

  299.                     }

  300. 

  301.     //! test for SH == 2 && SW == 2 && FH = FW = 4 max pooling

  302.     for (size_t ih :

  303.          {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  304.         for (size_t iw :

  305.              {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  306.             for (size_t p : {1, 2}) {

  307.                 Param param;

  308.                 param.mode = Param::Mode::MAX;

  309.                 param.window_h = param.window_w = 4;

  310.                 param.stride_h = param.stride_w = 2;

  311.                 param.pad_h = param.pad_w = p;

  312.                 checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  313.             }

  314. 

  315.     //! test for SH == 2 && SW == 2 && FH = FW = 5 max pooling

  316.     for (size_t ih :

  317.          {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  318.         for (size_t iw :

  319.              {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  320.             for (size_t p : {1, 2}) {

  321.                 Param param;

  322.                 param.mode = Param::Mode::MAX;

  323.                 param.window_h = param.window_w = 5;

  324.                 param.stride_h = param.stride_w = 2;

  325.                 param.pad_h = param.pad_w = p;

  326.                 checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  327.             }

  328. }

  329. #endif

  330. 

  331. TEST_F(ARM_COMMON, POOLING_QUANTIZED) {

  332.     Checker<Pooling> checker(handle());

  333.     UniformIntRNG rng1{INT8_MIN >> 1, INT8_MAX >> 1};

  334.     UniformIntRNG rng2{0, UINT8_MAX >> 1};

  335. 

  336.     using Param = param::Pooling;

  337. 

  338.     for (auto type : std::vector<DType>{

  339.                  dtype::QuantizedS8(1.1f),

  340.                  dtype::Quantized8Asymm(1.1f, static_cast<uint8_t>(3))}) {

  341.         if (type.enumv() == DTypeEnum::QuantizedS8) {

  342.             checker.set_rng(0, &rng1);

  343.         } else {

  344.             megdnn_assert(type.enumv() == DTypeEnum::Quantized8Asymm);

  345.             checker.set_rng(0, &rng2);

  346.         }

  347.         for (size_t ih : {2, 3, 5, 7, 11, 13, 17, 19, 23, 33, 49})

  348.             for (size_t iw : {2, 3, 5, 7, 11, 13, 17, 19, 23, 33, 49})

  349.                 for (auto mode : {Param::Mode::AVERAGE, Param::Mode::MAX}) {

  350.                     for (size_t window : {2, 3}) {

  351.                         Param param;

  352.                         param.mode = mode;

  353.                         param.window_h = param.window_w = window;

  354.                         param.stride_h = param.stride_w = 1;

  355.                         param.pad_h = param.pad_w = window / 2;

  356.                         //! test for SH == 1 && SW == 1 && FH == FW (FH == 2 ||

  357.                         //! FH

  358.                         //! == 3)

  359.                         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  360. 

  361.                         //! test for SH = SW = 2 && FH = FW = 2

  362.                         param.stride_h = param.stride_w = 2;

  363.                         checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  364.                     }

  365.                 }

  366. 

  367.         //! test for SH == 2 && SW == 2 && FH == FW == 3 max pooling

  368.         for (size_t ih : {2, 3, 7, 13, 52, 53, 54, 55})

  369.             for (size_t iw : {2, 3, 6, 14, 53, 54, 55, 56})

  370.                 for (size_t ph : {0, 1, 2})

  371.                     for (size_t pw : {0, 1, 2})

  372.                         if (ih + 2 * ph >= 3 && iw + 2 * pw >= 3) {

  373.                             param::Pooling param;

  374.                             param.mode = param::Pooling::Mode::MAX;

  375.                             param.pad_h = ph;

  376.                             param.pad_w = pw;

  377.                             param.window_h = param.window_w = 3;

  378.                             param.stride_h = param.stride_w = 2;

  379.                             checker.set_param(param).exec(

  380.                                     TensorShapeArray{{2, 3, ih, iw}, {}});

  381.                         }

  382. 

  383.         //! test for SH == 2 && SW == 2 && FH == FW == 4 max pooling

  384.         for (size_t ih :

  385.              {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  386.             for (size_t iw :

  387.                  {2, 3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  388.                 for (size_t p : {1, 2}) {

  389.                     Param param;

  390.                     param.mode = Param::Mode::MAX;

  391.                     param.window_h = param.window_w = 4;

  392.                     param.stride_h = param.stride_w = 2;

  393.                     param.pad_h = param.pad_w = p;

  394.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  395.                 }

  396. 

  397.         //! test for SH == 2 && SW == 2 && FH == FW == 5 max pooling

  398.         for (size_t ih :

  399.              {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  400.             for (size_t iw :

  401.                  {3, 5, 7, 11, 13, 17, 19, 23, 24, 25, 26, 27, 28, 29, 30})

  402.                 for (size_t p : {1, 2}) {

  403.                     Param param;

  404.                     param.mode = Param::Mode::MAX;

  405.                     param.window_h = param.window_w = 5;

  406.                     param.stride_h = param.stride_w = 2;

  407.                     param.pad_h = param.pad_w = p;

  408.                     checker.set_param(param).exec({{2, 3, ih, iw}, {}});

  409.                 }

  410.     }

  411. }

  412. 

  413. #if MEGDNN_WITH_BENCHMARK

  414. TEST_F(ARM_COMMON, BENCHMARK_POOLING_INT8_W3x3_S2x2)

  415. {

  416.     using Param = param::Pooling;

  417.     auto run = [&](const TensorShapeArray &shapes,

  418.             Param param) {

  419.         auto handle_naive = create_cpu_handle(2);

  420.         TensorLayoutArray layouts;

  421.         layouts.emplace_back(shapes[0], dtype::Int8());

  422.         layouts.emplace_back(shapes[1], dtype::Int8());

  423.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  424.         Benchmarker<Pooling> benchmarker_float(handle());

  425.         Benchmarker<Pooling> benchmarker_int(handle());

  426.         size_t RUN = 10;

  427.         auto t1 = benchmarker_naive.set_display(false).set_times(RUN).

  428.             set_param(param).exec(shapes);

  429.         auto t2 = benchmarker_float.set_display(false).set_times(RUN).

  430.             set_param(param).exec(shapes);

  431.         auto t3 = benchmarker_int.set_display(false).set_times(RUN).

  432.             set_param(param).execl(layouts);

  433.         printf("naive=%.3fms float=%.3fms, int=%.3fms\n",

  434.                 t1 / RUN, t2 / RUN, t3 / RUN);

  435.         auto speedup = t2/t3;

  436.         ASSERT_GE(speedup, 2.0);

  437.     };

  438.     Param param;

  439.     param.window_h = param.window_w = 3;

  440.     param.stride_h = param.stride_w = 2;

  441.     param.pad_h = param.pad_w = 1;

  442.     std::cout << "3x3 with 2x2 stride max pooling:" << std::endl;

  443.     run({{1, 3, 640, 480}, {}}, param);

  444. }

  445. 

  446. TEST_F(ARM_COMMON, BENCHMARK_POOLING_W4x4_S2x2)

  447. {

  448.     using Param = param::Pooling;

  449.     auto run = [&](const TensorShapeArray &shapes,

  450.             Param param) {

  451.         std::cout << "N:" << shapes[0][0] << " "

  452.                   << "IC:" << shapes[0][1] << " "

  453.                   << "IH:" << shapes[0][2] << " "

  454.                   << "IW:" << shapes[0][3] << std::endl;

  455.         auto handle_naive = create_cpu_handle(2);

  456.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  457.         Benchmarker<Pooling> benchmarker_float(handle());

  458.         size_t RUN = 10;

  459.         auto t1 = benchmarker_naive.set_display(false).set_times(RUN).

  460.             set_param(param).exec(shapes);

  461.         auto t2 = benchmarker_float.set_display(false).set_times(RUN).

  462.             set_param(param).exec(shapes);

  463.         TensorLayout dst_layout;

  464.         auto opr = handle()->create_operator<Pooling>();

  465.         opr->param() = param;

  466.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  467.         float calc_amount = dst_layout.total_nr_elems() *

  468.                             param.window_h * param.window_w;

  469.         printf("naive={%.3fms, %.3fMflops}, neon={%.3fms, %.3fMflops}\n",

  470.                t1 / RUN, calc_amount / (t1 / RUN * 1000),

  471.                t2 / RUN, calc_amount / (t2 / RUN * 1000));

  472.     };

  473.     Param param;

  474.     param.window_h = param.window_w = 4;

  475.     param.stride_h = param.stride_w = 2;

  476.     param.pad_h = param.pad_w = 1;

  477.     std::cout << "4x4 with 2x2 stride max pooling:" << std::endl;

  478.     run({{1, 24, 160, 128}, {}}, param);

  479.     run({{1, 4, 240, 135}, {}}, param);

  480.     run({{1, 32, 120, 67}, {}}, param);

  481.     run({{1, 64, 60, 33}, {}}, param);

  482. }

  483. 

  484. TEST_F(ARM_COMMON, BENCHMARK_POOLING_W5x5_S2x2)

  485. {

  486.     using Param = param::Pooling;

  487.     auto run = [&](const TensorShapeArray &shapes,

  488.             Param param) {

  489.         std::cout << "N:" << shapes[0][0] << " "

  490.                   << "IC:" << shapes[0][1] << " "

  491.                   << "IH:" << shapes[0][2] << " "

  492.                   << "IW:" << shapes[0][3] << std::endl;

  493.         auto handle_naive = create_cpu_handle(2);

  494.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  495.         Benchmarker<Pooling> benchmarker_float(handle());

  496.         size_t RUN = 10;

  497.         auto t1 = benchmarker_naive.set_display(false).set_times(RUN).

  498.             set_param(param).exec(shapes);

  499.         auto t2 = benchmarker_float.set_display(false).set_times(RUN).

  500.             set_param(param).exec(shapes);

  501.         TensorLayout dst_layout;

  502.         auto opr = handle()->create_operator<Pooling>();

  503.         opr->param() = param;

  504.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  505.         float calc_amount = dst_layout.total_nr_elems() *

  506.                             param.window_h * param.window_w;

  507.         printf("naive={%.3fms, %.3fMflops}, neon={%.3fms, %.3fMflops}\n",

  508.                t1 / RUN, calc_amount / (t1 / RUN * 1000),

  509.                t2 / RUN, calc_amount / (t2 / RUN * 1000));

  510.     };

  511.     Param param;

  512.     param.window_h = param.window_w = 5;

  513.     param.stride_h = param.stride_w = 2;

  514.     param.pad_h = param.pad_w = 1;

  515.     std::cout << "5x5 with 2x2 stride max pooling:" << std::endl;

  516.     run({{1, 24, 160, 128}, {}}, param);

  517.     run({{1, 4, 240, 135}, {}}, param);

  518.     run({{1, 32, 120, 67}, {}}, param);

  519.     run({{1, 64, 60, 33}, {}}, param);

  520. }

  521. 

  522. 

  523. TEST_F(ARM_COMMON, BENCHMARK_POOLING_FP16) {

  524.     using Param = param::Pooling;

  525.     auto run = [&](const TensorShapeArray& shapes, Param param) {

  526.         TensorLayoutArray layouts;

  527.         layouts.emplace_back(shapes[0], dtype::Float16());

  528.         layouts.emplace_back(shapes[1], dtype::Float16());

  529.         Benchmarker<Pooling> benchmarker_float(handle());

  530.         Benchmarker<Pooling> benchmarker_half(handle());

  531.         size_t RUN = 10;

  532.         auto tf = benchmarker_float.set_display(false)

  533.                           .set_times(RUN)

  534.                           .set_param(param)

  535.                           .exec(shapes) /

  536.                   RUN;

  537.         auto th = benchmarker_half.set_display(false)

  538.                           .set_times(RUN)

  539.                           .set_param(param)

  540.                           .execl(layouts) /

  541.                   RUN;

  542.         TensorLayout dst_layout;

  543.         auto opr = handle()->create_operator<Pooling>();

  544.         opr->param() = param;

  545.         opr->deduce_layout({shapes[0], dtype::Float32()}, dst_layout);

  546. 

  547.         float computations = dst_layout.total_nr_elems() * param.window_h *

  548.                              param.window_w / (1024.f * 1024 * 1024);

  549.         printf("float=%.3fms %f gflops, float16=%.3fms %f gflops speedup: %f\n",

  550.                tf, computations / tf * 1e3, th, computations / th * 1e3,

  551.                tf / th);

  552.     };

  553.     Param param;

  554.     param.window_h = param.window_w = 2;

  555.     param.stride_h = param.stride_w = 1;

  556.     param.pad_h = param.pad_w = 1;

  557.     printf("2x2 with 1x1 stride max pooling:\n");

  558.     run({{1, 3, 640, 480}, {}}, param);

  559. 

  560.     for (size_t oh : {640, 128})

  561.         for (size_t ow : {480, 112}) {

  562.             param.window_h = param.window_w = 3;

  563.             param.stride_h = param.stride_w = 2;

  564.             param.pad_h = param.pad_w = 1;

  565.             param.mode = Param::Mode::AVERAGE;

  566.             printf("3x3 with 2x2 stride average pooling.\n");

  567.             run({{1, 3, oh, ow}, {}}, param);

  568. 

  569.             for (size_t pw : {2, 3, 4, 5}) {

  570.                 param.window_h = param.window_w = pw;

  571.                 param.stride_h = param.stride_w = 2;

  572.                 param.pad_h = param.pad_w = 1;

  573.                 param.mode = Param::Mode::MAX;

  574.                 printf("%zux%zu with 2x2 stride max pooling:\n", pw, pw);

  575.                 run({{1, 3, oh, ow}, {}}, param);

  576.             }

  577.         }

  578. }

  579. 

  580. TEST_F(ARM_COMMON, BENCHMARK_POOLING_QUANTIZED) {

  581.     using Param = param::Pooling;

  582.     auto run = [&](const TensorShapeArray& shapes, Param param) {

  583.         auto handle_naive = create_cpu_handle(2);

  584.         TensorLayoutArray layouts;

  585.         layouts.emplace_back(shapes[0], dtype::QuantizedS8(1.1f));

  586.         layouts.emplace_back(shapes[1], dtype::QuantizedS8(1.1f));

  587.         Benchmarker<Pooling> benchmarker_int(handle());

  588.         Benchmarker<Pooling> benchmarker_naive(handle_naive.get());

  589.         size_t RUN = 10;

  590.         auto time_int = benchmarker_int.set_display(false)

  591.                                 .set_times(RUN)

  592.                                 .set_param(param)

  593.                                 .exec(shapes) /

  594.                         RUN;

  595.         auto time_naive = benchmarker_naive.set_display(false)

  596.                                   .set_times(RUN)

  597.                                   .set_param(param)

  598.                                   .execl(layouts) /

  599.                           RUN;

  600.         TensorLayout dst_layout;

  601.         auto opr = handle()->create_operator<Pooling>();

  602.         opr->param() = param;

  603.         opr->deduce_layout({shapes[0], dtype::QuantizedS8(1.1f)}, dst_layout);

  604. 

  605.         float computations = dst_layout.total_nr_elems() * param.window_h *

  606.                              param.window_w / (1024.f * 1024 * 1024);

  607.         printf("naive=%.3fms %f gflops, int8=%.3fms %f gflops speedup: %f\n",

  608.                time_naive, computations / time_naive * 1e3, time_int,

  609.                computations / time_int * 1e3, time_naive / time_int);

  610.     };

  611.     Param param;

  612.     param.window_h = param.window_w = 2;

  613.     param.stride_h = param.stride_w = 1;

  614.     param.pad_h = param.pad_w = 1;

  615.     printf("2x2 with 1x1 stride max pooling:\n");

  616.     run({{1, 3, 640, 480}, {}}, param);

  617. 

  618.     // clang-format off

  619.     for (size_t oh : {640, 128})

  620.     for (size_t ow : {480, 112})

  621.     for (size_t pw : {2, 3, 4, 5}) {

  622.         param.window_h = param.window_w = pw;

  623.         param.stride_h = param.stride_w = 2;

  624.         param.pad_h = param.pad_w = 1;

  625.         printf("%zux%zu with 2x2 stride max pooling:\n", pw, pw);

  626.         run({{1, 3, oh, ow}, {}}, param);

  627.     }

  628.     // clang-format on

  629. }

  630. #endif

  631. 

  632. }  // namespace test

  633. }  // namespace megdnn

  634.    // vim: syntax=cpp.doxygen