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: 3eb0505f9b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3eb0505f9b'
${ noResults }
MegEngine/dnn/test/common/conv_bias.cpp

1385 lines
54 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/common/conv_bias.cpp

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

  4.  *

  5.  * Copyright (c) 2014-2021 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

  10.  * implied.

  11.  */

  12. #include "test/common/conv_bias.h"

  13. #include "megdnn/opr_param_defs.h"

  14. #include "src/common/utils.h"

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

  16. namespace megdnn {

  17. namespace test {

  18. namespace conv_bias {

  19. 

  20. namespace {

  21. void convert_arg_from_nchw4_to_chwn4(TestArg& arg) {

  22.     arg.param.format = param::ConvBias::Format::CHWN4;

  23.     arg.src = TensorShape{arg.src[1], arg.src[2], arg.src[3], arg.src[0], 4};

  24.     arg.filter = TensorShape{arg.filter[1], arg.filter[2], arg.filter[3],

  25.                              arg.filter[0], 4};

  26.     arg.bias =

  27.             TensorShape{arg.bias[1], arg.bias[2], arg.bias[3], arg.bias[0], 4};

  28. }

  29. }  // namespace

  30. 

  31. std::vector<TestArg> get_args() {

  32.     std::vector<TestArg> args;

  33. 

  34.     param::ConvBias cur_param;

  35. 

  36.     using NLMode = param::ConvBias::NonlineMode;

  37. 

  38.     // clang-format off

  39.     for (auto nlmode :

  40.          {NLMode::IDENTITY, NLMode::RELU, NLMode::SIGMOID, NLMode::H_SWISH}) {

  41.     for (size_t i : {9, 63}) {

  42.         cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  43.         cur_param.nonlineMode = nlmode;

  44.         // fallback case

  45.         args.emplace_back(cur_param, TensorShape{10, 1, i, i},

  46.                           TensorShape{1, 1, 8, 8}, TensorShape{1, 1, 1, 1});

  47. 

  48.         args.emplace_back(cur_param, TensorShape{10, 4, i, i},

  49.                           TensorShape{3, 4, 4, 4}, TensorShape{1, 3, 1, 1});

  50. 

  51.         cur_param.mode = param::ConvBias::Mode::CONVOLUTION;

  52.         args.emplace_back(cur_param, TensorShape{10, 4, i, i},

  53.                           TensorShape{1, 4, 3, 3}, TensorShape{1, 1, 1, 1});

  54. 

  55.         args.emplace_back(cur_param, TensorShape{1, 4, i, i},

  56.                           TensorShape{5, 4, 3, 3}, TensorShape{1, 5, 1, 1});

  57.     } }

  58.     // clang-format on

  59. 

  60.     return args;

  61. }

  62. 

  63. std::vector<TestArg> get_chanwise_args() {

  64.     std::vector<TestArg> args;

  65.     param::ConvBias cur_param;

  66.     using NLMode = param::ConvBias::NonlineMode;

  67.     cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  68.     cur_param.sparse = ConvBias::Param::Sparse::GROUP;

  69. 

  70.     for (auto nlmode :

  71.          {NLMode::IDENTITY, NLMode::RELU, NLMode::SIGMOID, NLMode::H_SWISH}) {

  72.         cur_param.nonlineMode = nlmode;

  73.         // simple case

  74.         for (uint32_t s : {1, 2})

  75.             for (uint32_t p : {0, 1, 2, 3})

  76.                 for (size_t f : {2, 3, 5, 7})

  77.                     for (size_t ocpg : {1, 3}) {

  78.                         cur_param.pad_h = cur_param.pad_w = p;

  79.                         cur_param.stride_h = cur_param.stride_w = s;

  80.                         args.emplace_back(cur_param, TensorShape{2, 3, 16, 16},

  81.                                           TensorShape{3, ocpg, 1, f, f},

  82.                                           TensorShape{1, 3 * ocpg, 1, 1});

  83.                     }

  84. 

  85.         args.emplace_back(cur_param, TensorShape{32, 12, 20, 10},

  86.                           TensorShape{12, 2, 1, 4, 5},

  87.                           TensorShape{1, 24, 1, 1});

  88. 

  89.         // padding larger than kern

  90.         args.emplace_back(cur_param, TensorShape{32, 12, 20, 10},

  91.                           TensorShape{12, 2, 1, 4, 5},

  92.                           TensorShape{1, 24, 1, 1});

  93.     }

  94.     return args;

  95. }

  96. 

  97. std::vector<TestArg> get_args_1x1() {

  98.     std::vector<TestArg> args;

  99.     param::ConvBias cur_param;

  100.     using NLMode = param::ConvBias::NonlineMode;

  101. 

  102.     for (auto nlmode :

  103.          {NLMode::IDENTITY, NLMode::RELU, NLMode::SIGMOID, NLMode::H_SWISH}) {

  104.         cur_param.nonlineMode = nlmode;

  105.         for (size_t i : {16, 19}) {

  106.             cur_param.mode = param::ConvBias::Mode::CONVOLUTION;

  107.             args.emplace_back(cur_param, TensorShape{2, 20, i, i + 1},

  108.                               TensorShape{30, 20, 1, 1},

  109.                               TensorShape{1, 30, 1, 1});

  110. 

  111.             cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  112.             args.emplace_back(cur_param, TensorShape{2, 20, i, i + 1},

  113.                               TensorShape{30, 20, 1, 1},

  114.                               TensorShape{1, 30, 1, 1});

  115.         }

  116.     }

  117.     return args;

  118. }

  119. 

  120. std::vector<TestArg> get_winograd_args(size_t kernel_size) {

  121.     std::vector<TestArg> args;

  122. 

  123.     param::ConvBias cur_param;

  124. 

  125.     using NLMode = param::ConvBias::NonlineMode;

  126. 

  127.     // clang-format off

  128.     for (auto nlmode :

  129.          {NLMode::IDENTITY, NLMode::RELU, NLMode::SIGMOID, NLMode::H_SWISH}) {

  130.     for (size_t ic : {1, 3, 4, 7}) {

  131.     for (size_t oc : {1, 3, 4, 7}) {

  132.     for (size_t i : {9, 63}) {

  133.         cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  134.         cur_param.nonlineMode = nlmode;

  135. 

  136.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  137.         cur_param.pad_h = cur_param.pad_w = 0;

  138. 

  139.         //! no bias

  140.         args.emplace_back(cur_param, TensorShape{1, ic, i, i},

  141.                           TensorShape{oc, ic, kernel_size, kernel_size},

  142.                           TensorShape{});

  143. 

  144.         //! bias

  145.         args.emplace_back(

  146.                 cur_param, TensorShape{2, ic, i, i},

  147.                 TensorShape{oc, ic, kernel_size, kernel_size},

  148.                 TensorShape{2, oc, (i + cur_param.pad_h * 2 - kernel_size) + 1,

  149.                             (i + cur_param.pad_w * 2 - kernel_size) + 1});

  150. 

  151.         //! bias channel

  152.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  153.                           TensorShape{oc, ic, kernel_size, kernel_size},

  154.                           TensorShape{1, oc, 1, 1});

  155. 

  156.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  157.         args.emplace_back(

  158.                 cur_param, TensorShape{2, 2 * ic, i, i},

  159.                 TensorShape{2, oc, ic, kernel_size, kernel_size},

  160.                 TensorShape{2, 2 * oc,

  161.                             (i + cur_param.pad_h * 2 - kernel_size) + 1,

  162.                             (i + cur_param.pad_w * 2 - kernel_size) + 1});

  163. 

  164.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  165.                           TensorShape{2, oc, ic, kernel_size, kernel_size},

  166.                           TensorShape{1, 2 * oc, 1, 1});

  167.     } } } }

  168.     // clang-format on

  169.     //! test for multi-thread OC parallel

  170.     for (size_t i : {9, 63}) {

  171.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  172.         cur_param.pad_h = cur_param.pad_w = 1;

  173.         args.emplace_back(cur_param, TensorShape{1, 8, i, i},

  174.                           TensorShape{128, 8, kernel_size, kernel_size},

  175.                           TensorShape{1, 128, 1, 1});

  176.         args.emplace_back(cur_param, TensorShape{2, 8, i, i},

  177.                           TensorShape{128, 8, kernel_size, kernel_size},

  178.                           TensorShape{1, 128, 1, 1});

  179.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  180.         args.emplace_back(cur_param, TensorShape{2, 2 * 8, i, i},

  181.                           TensorShape{2, 128, 8, kernel_size, kernel_size},

  182.                           TensorShape{1, 2 * 128, 1, 1});

  183.     }

  184.     return args;

  185. }

  186. 

  187. std::vector<TestArg> get_winograd_mk_packed_args(size_t pack_size) {

  188.     std::vector<TestArg> args;

  189. 

  190.     param::ConvBias cur_param;

  191. 

  192.     using NLMode = param::ConvBias::NonlineMode;

  193. 

  194.     // clang-format off

  195.     for (auto nlmode :

  196.          {NLMode::IDENTITY, NLMode::RELU, NLMode::SIGMOID, NLMode::H_SWISH}) {

  197.     for (size_t ic : {pack_size, 2 * pack_size}) {

  198.     for (size_t oc : {pack_size, 2 * pack_size}) {

  199.     for (size_t i : {9, 63}) {

  200.         cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  201.         cur_param.nonlineMode = nlmode;

  202. 

  203.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  204.         cur_param.pad_h = cur_param.pad_w = 1;

  205. 

  206.         args.emplace_back(cur_param, TensorShape{1, pack_size, 3, 3},

  207.                           TensorShape{pack_size, pack_size, 3, 3},

  208.                           TensorShape{1, pack_size, 1, 1});

  209.         //! no bias

  210.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  211.                           TensorShape{oc, ic, 3, 3}, TensorShape{});

  212. 

  213.         //! bias

  214.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  215.                           TensorShape{oc, ic, 3, 3}, TensorShape{2, oc, i, i});

  216. 

  217.         //! bias channel

  218.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  219.                           TensorShape{oc, ic, 3, 3}, TensorShape{1, oc, 1, 1});

  220. 

  221.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  222.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  223.                           TensorShape{2, oc, ic, 3, 3},

  224.                           TensorShape{2, 2 * oc, i, i});

  225. 

  226.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  227.                           TensorShape{2, oc, ic, 3, 3},

  228.                           TensorShape{1, 2 * oc, 1, 1});

  229.     } } } }

  230.     // clang-format on

  231.     //! test for multi-thread OC parallel

  232.     for (size_t i : {9, 63}) {

  233.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  234.         cur_param.pad_h = cur_param.pad_w = 1;

  235.         args.emplace_back(cur_param, TensorShape{1, 8, i, i},

  236.                           TensorShape{128, 8, 3, 3}, TensorShape{1, 128, 1, 1});

  237.         args.emplace_back(cur_param, TensorShape{2, 8, i, i},

  238.                           TensorShape{128, 8, 3, 3}, TensorShape{1, 128, 1, 1});

  239.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  240.         args.emplace_back(cur_param, TensorShape{2, 2 * 8, i, i},

  241.                           TensorShape{2, 128, 8, 3, 3},

  242.                           TensorShape{1, 2 * 128, 1, 1});

  243.     }

  244.     return args;

  245. }

  246. 

  247. std::vector<TestArg> get_quantized_winograd_mk_packed_args(

  248.         size_t pack_size, bool compute_float32) {

  249.     std::vector<TestArg> args;

  250. 

  251.     param::ConvBias cur_param;

  252. 

  253.     using NLMode = param::ConvBias::NonlineMode;

  254. 

  255.     // clang-format off

  256.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  257.     for (size_t ic : {pack_size, 2 * pack_size}) {

  258.     for (size_t oc : {pack_size, 2 * pack_size}) {

  259.     for (size_t i : {9, 63}) {

  260.         cur_param.mode = param::ConvBias::Mode::CROSS_CORRELATION;

  261.         cur_param.nonlineMode = nlmode;

  262. 

  263.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  264.         cur_param.pad_h = cur_param.pad_w = 1;

  265. 

  266.         if(compute_float32){

  267.             cur_param.compute_mode = param::ConvBias::ComputeMode::FLOAT32;

  268.         }

  269. 

  270.         args.emplace_back(cur_param, TensorShape{1, pack_size, 3, 3},

  271.                           TensorShape{pack_size, pack_size, 3, 3},

  272.                           TensorShape{1, pack_size, 1, 1});

  273.         //! no bias

  274.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  275.                           TensorShape{oc, ic, 3, 3}, TensorShape{});

  276.         //! bias

  277.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  278.                           TensorShape{oc, ic, 3, 3}, TensorShape{2, oc, i, i});

  279. 

  280.         //! bias channel

  281.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  282.                           TensorShape{oc, ic, 3, 3}, TensorShape{1, oc, 1, 1});

  283. 

  284.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  285.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  286.                           TensorShape{2, oc, ic, 3, 3},

  287.                           TensorShape{2, 2 * oc, i, i});

  288. 

  289.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  290.                           TensorShape{2, oc, ic, 3, 3},

  291.                           TensorShape{1, 2 * oc, 1, 1});

  292.     } } } }

  293.     // clang-format on

  294.     //! test for multi-thread OC parallel

  295.     for (size_t i : {9, 63}) {

  296.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  297.         cur_param.pad_h = cur_param.pad_w = 1;

  298.         args.emplace_back(cur_param, TensorShape{1, 8, i, i},

  299.                           TensorShape{128, 8, 3, 3}, TensorShape{1, 128, 1, 1});

  300.         args.emplace_back(cur_param, TensorShape{2, 8, i, i},

  301.                           TensorShape{128, 8, 3, 3}, TensorShape{1, 128, 1, 1});

  302.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  303.         args.emplace_back(cur_param, TensorShape{2, 2 * 8, i, i},

  304.                           TensorShape{2, 128, 8, 3, 3},

  305.                           TensorShape{1, 2 * 128, 1, 1});

  306.     }

  307.     return args;

  308. }

  309. 

  310. std::vector<TestArg> get_quantized_args_with_nlmode(

  311.         param::ConvBias::NonlineMode nlmode) {

  312.     std::vector<TestArg> args;

  313.     param::ConvBias cur_param;

  314. 

  315.     // clang-format off

  316.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION,

  317.                       param::ConvBias::Mode::CONVOLUTION}) {

  318.     for (size_t ic : {1, 2, 3, 4, 5, 7}) {

  319.     for (size_t oc : {1, 2, 3, 4, 5, 7}) {

  320.     for (size_t i : {9, 63}) {

  321.         cur_param.mode = mode;

  322.         cur_param.nonlineMode = nlmode;

  323. 

  324.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  325.         cur_param.pad_h = cur_param.pad_w = 1;

  326. 

  327.         //! no bias

  328.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  329.                           TensorShape{oc, ic, 3, 3}, TensorShape{});

  330. 

  331.         //! bias

  332.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  333.                           TensorShape{oc, ic, 3, 3}, TensorShape{2, oc, i, i});

  334. 

  335.         //! bias channel

  336.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  337.                           TensorShape{oc, ic, 3, 3}, TensorShape{1, oc, 1, 1});

  338. 

  339.         cur_param.sparse = param::ConvBias::Sparse::GROUP;

  340.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  341.                           TensorShape{2, oc, ic, 3, 3},

  342.                           TensorShape{2, 2 * oc, i, i});

  343. 

  344.         args.emplace_back(cur_param, TensorShape{2, 2 * ic, i, i},

  345.                           TensorShape{2, oc, ic, 3, 3},

  346.                           TensorShape{1, 2 * oc, 1, 1});

  347. 

  348.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  349.         cur_param.pad_h = cur_param.pad_w = 0;

  350.         args.emplace_back(cur_param, TensorShape{2, ic, i, i},

  351.                           TensorShape{oc, ic, 1, 1}, TensorShape{});

  352.     } } } }

  353.     // clang-format on

  354. 

  355.     return args;

  356. }

  357. 

  358. std::vector<TestArg> get_quantized_args() {

  359.     using NLMode = param::ConvBias::NonlineMode;

  360.     auto arg_p1 = get_quantized_args_with_nlmode(NLMode::IDENTITY),

  361.          arg_p2 = get_quantized_args_with_nlmode(NLMode::RELU),

  362.          arg_p3 = get_quantized_args_with_nlmode(NLMode::H_SWISH);

  363.     std::vector<TestArg> args;

  364.     args.insert(args.end(), arg_p1.begin(), arg_p1.end());

  365.     args.insert(args.end(), arg_p2.begin(), arg_p2.end());

  366.     args.insert(args.end(), arg_p3.begin(), arg_p3.end());

  367.     return args;

  368. }

  369. 

  370. std::vector<TestArg> get_int8_nchw4_args(size_t kernel_size) {

  371.     std::vector<TestArg> args;

  372.     param::ConvBias cur_param;

  373. 

  374.     using NLMode = param::ConvBias::NonlineMode;

  375. 

  376.     // clang-format off

  377.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  378.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  379.     for (size_t b : {64, 16}) {

  380.     for (size_t ic : {16, 32}) {

  381.     for (size_t oc : {16, 32}) {

  382.     for (size_t h : {8}) {

  383.     for (size_t w : {8, 11}) {

  384.     for (int p : {0, static_cast<int>(kernel_size / 2)}) {

  385.     for (size_t s : {2, 1}) {

  386.         if (kernel_size == 7) {

  387.             b = std::min(b, 32_z);

  388.         }

  389.         size_t f = kernel_size;

  390.         cur_param.mode = mode;

  391.         cur_param.nonlineMode = nlmode;

  392. 

  393.         cur_param.format = param::ConvBias::Format::NCHW4;

  394.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  395.         cur_param.pad_h = cur_param.pad_w = p;

  396.         cur_param.stride_h = cur_param.stride_w = s;

  397. 

  398.         //! bias channel

  399.         args.emplace_back(cur_param, TensorShape{b, ic / 4, h, w, 4},

  400.                           TensorShape{oc, ic / 4, f, f, 4},

  401.                           TensorShape{1, oc / 4, 1, 1, 4});

  402.     } } } } } } } } }

  403.     // clang-format on

  404. 

  405.     return args;

  406. }

  407. 

  408. std::vector<TestArg> get_int8_nchw44_args(size_t kernel_size, size_t pack_size,

  409.                                           bool compute_float32,

  410.                                           bool group_mode) {

  411.     std::vector<TestArg> args;

  412.     param::ConvBias cur_param;

  413.     megdnn_assert(pack_size > 0, "not support pack_size");

  414.     megdnn_assert(kernel_size > 0, "not support kernel_size");

  415.     using NLMode = param::ConvBias::NonlineMode;

  416. 

  417.     // clang-format off

  418.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  419.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  420.     for (size_t b : {1,2}) {

  421.     for (size_t ic : {8,16}) {

  422.     for (size_t oc : {8,16}) {

  423.     for (size_t h : {9,23}) {

  424.     for (size_t w : {9,23}) {

  425.     for (int p : {0, static_cast<int>(kernel_size / 2)}) {

  426.     for (size_t s : {1}) {

  427.         if (kernel_size == 7) {

  428.             b = std::min(b, 32_z);

  429.         }

  430.         size_t f = kernel_size;

  431.         cur_param.mode = mode;

  432.         cur_param.nonlineMode = nlmode;

  433.         if (pack_size == 4){

  434.             cur_param.format = param::ConvBias::Format::NCHW44;

  435.         } else if(pack_size == 8){

  436.             cur_param.format = param::ConvBias::Format::NCHW88;

  437.         }

  438. 

  439.         if(compute_float32){

  440.             cur_param.compute_mode =

  441.                     param::ConvBias::ComputeMode::FLOAT32;

  442.         }

  443. 

  444.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  445.         cur_param.pad_h = cur_param.pad_w = p;

  446.         cur_param.stride_h = cur_param.stride_w = s;

  447.         if (!group_mode) {

  448.             //! no bias

  449.             args.emplace_back(cur_param,

  450.                               TensorShape{b, ic / pack_size, h, w, pack_size},

  451.                               TensorShape{oc / pack_size, ic / pack_size, f, f,

  452.                                           pack_size, pack_size},

  453.                               TensorShape{});

  454. 

  455.             //! bias channel

  456.             args.emplace_back(cur_param,

  457.                               TensorShape{b, ic / pack_size, h, w, pack_size},

  458.                               TensorShape{oc / pack_size, ic / pack_size, f, f,

  459.                                           pack_size, pack_size},

  460.                               TensorShape{1, oc / pack_size, 1, 1, pack_size});

  461.             //! bias

  462.             args.emplace_back(

  463.                     cur_param, TensorShape{b, ic / pack_size, h, w, pack_size},

  464.                     TensorShape{oc / pack_size, ic / pack_size, f, f, pack_size,

  465.                                 pack_size},

  466.                     TensorShape{b, oc / pack_size, (h - f + 2 * p) / s + 1,

  467.                                 (w - f + 2 * p) / s + 1, pack_size});

  468.         } else {

  469.             cur_param.sparse = param::ConvBias::Sparse::GROUP;

  470.             args.emplace_back(

  471.                     cur_param,

  472.                     TensorShape{2, 2 * ic / pack_size, h, w, pack_size},

  473.                     TensorShape{2, oc / pack_size, ic / pack_size, 3, 3,

  474.                                 pack_size, pack_size},

  475.                     TensorShape{2, 2 * oc / pack_size, (h - f + 2 * p) / s + 1,

  476.                                 (w - f + 2 * p) / s + 1, pack_size});

  477. 

  478.             args.emplace_back(

  479.                     cur_param,

  480.                     TensorShape{2, 2 * ic / pack_size, h, w, pack_size},

  481.                     TensorShape{2, oc / pack_size, ic / pack_size, f, f,

  482.                                 pack_size, pack_size},

  483.                     TensorShape{1, 2 * oc / pack_size, 1, 1, pack_size});

  484.             args.emplace_back(

  485.                     cur_param,

  486.                     TensorShape{2, 2 * ic / pack_size, h, w, pack_size},

  487.                     TensorShape{2, oc / pack_size, ic / pack_size, f, f,

  488.                                 pack_size, pack_size},

  489.                     TensorShape{});

  490.         }

  491.     } } } } } } } } }

  492.     // clang-format on

  493. 

  494.     return args;

  495. }

  496. 

  497. std::vector<TestArg> get_int8_nchw4_args_check_bounds(size_t kernel_size) {

  498.     std::vector<TestArg> args;

  499.     param::ConvBias cur_param;

  500. 

  501.     using NLMode = param::ConvBias::NonlineMode;

  502. 

  503.     // clang-format off

  504.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  505.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  506.     for (size_t b : {7, 8, 4, 1}) {

  507.     for (size_t ic : {16, 32}) {

  508.     for (size_t oc : {16, 8, 4}) {

  509.     for (size_t h : {8}) {

  510.     for (size_t w : {8, 11}) {

  511.     for (int p : {static_cast<int>(kernel_size / 2), 0}) {

  512.     for (size_t s : {1, 2}) {

  513.         size_t f = kernel_size;

  514.         cur_param.mode = mode;

  515.         cur_param.nonlineMode = nlmode;

  516. 

  517.         cur_param.format = param::ConvBias::Format::NCHW4;

  518.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  519.         cur_param.pad_h = cur_param.pad_w = p;

  520.         cur_param.stride_h = cur_param.stride_w = s;

  521. 

  522.         //! bias channel

  523.         args.emplace_back(cur_param, TensorShape{b, ic / 4, h, w, 4},

  524.                           TensorShape{oc, ic / 4, f, f, 4},

  525.                           TensorShape{1, oc / 4, 1, 1, 4});

  526.     } } } } } } } } }

  527.     // clang-format on

  528. 

  529.     return args;

  530. }

  531. 

  532. std::vector<TestArg> get_int8_nchw4_args_small_batch(size_t kernel_size) {

  533.     std::vector<TestArg> args;

  534.     param::ConvBias cur_param;

  535. 

  536.     using NLMode = param::ConvBias::NonlineMode;

  537. 

  538.     // clang-format off

  539.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  540.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  541.     for (size_t b : {12, 8, 4}) {

  542.     for (size_t ic : {16, 32}) {

  543.     for (size_t oc : {16, 8, 4}) {

  544.     for (size_t h : {8}) {

  545.     for (size_t w : {8, 9, 10, 11, 12, 13, 14, 15, 16}) {

  546.     for (int p : {static_cast<int>(kernel_size / 2), 0}) {

  547.     for (size_t s : {1, 2}) {

  548.         size_t f = kernel_size;

  549.         cur_param.mode = mode;

  550.         cur_param.nonlineMode = nlmode;

  551. 

  552.         cur_param.format = param::ConvBias::Format::NCHW4;

  553.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  554.         cur_param.pad_h = cur_param.pad_w = p;

  555.         cur_param.stride_h = cur_param.stride_w = s;

  556. 

  557.         //! bias channel

  558.         args.emplace_back(cur_param, TensorShape{b, ic / 4, h, w, 4},

  559.                           TensorShape{oc, ic / 4, f, f, 4},

  560.                           TensorShape{1, oc / 4, 1, 1, 4});

  561.     } } } } } } } } }

  562.     // clang-format on

  563. 

  564.     return args;

  565. }

  566. 

  567. std::vector<TestArg> get_int8_nchw4_small_channel_args(size_t kernel_size) {

  568.     std::vector<TestArg> args;

  569.     param::ConvBias cur_param;

  570. 

  571.     using NLMode = param::ConvBias::NonlineMode;

  572. 

  573.     // clang-format off

  574.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  575.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  576.     for (size_t b : {64, 16}) {

  577.     for (size_t ic : {4, 12}) {

  578.     for (size_t oc : {128, 32}) {

  579.     for (size_t h : {8}) {

  580.     for (size_t w : {8, 11}) {

  581.     for (int p : {static_cast<int>(kernel_size / 2), 0}) {

  582.     for (size_t s : {1, 2}) {

  583.         size_t f = kernel_size;

  584.         cur_param.mode = mode;

  585.         cur_param.nonlineMode = nlmode;

  586. 

  587.         cur_param.format =

  588.                 param::ConvBias::Format::NCHW4;

  589.         cur_param.sparse =

  590.                 param::ConvBias::Sparse::DENSE;

  591.         cur_param.pad_h = cur_param.pad_w = p;

  592.         cur_param.stride_h =

  593.                 cur_param.stride_w = s;

  594. 

  595.         //! bias channel

  596.         args.emplace_back(

  597.                 cur_param,

  598.                 TensorShape{b, ic / 4, h, w, 4},

  599.                 TensorShape{oc, ic / 4, f, f,

  600.                             4},

  601.                 TensorShape{1, oc / 4, 1, 1,

  602.                             4});

  603. 

  604.     } } } } } } } } }

  605.     // clang-format on

  606. 

  607.     return args;

  608. }

  609. 

  610. std::vector<TestArg> get_int8_nchw4_small_channel_args_check_bounds(

  611.         size_t kernel_size) {

  612.     std::vector<TestArg> args;

  613.     param::ConvBias cur_param;

  614. 

  615.     using NLMode = param::ConvBias::NonlineMode;

  616. 

  617.     // clang-format off

  618.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  619.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  620.     for (size_t b : {8, 7, 4, 1}) {

  621.     for (size_t ic : {4, 12}) {

  622.     for (size_t oc : {16, 8, 12, 4}) {

  623.     for (size_t h : {8}) {

  624.     for (size_t w : {8, 11}) {

  625.     for (int p : {static_cast<int>(kernel_size / 2), 0}) {

  626.     for (size_t s : {1, 2}) {

  627.         size_t f = kernel_size;

  628.         cur_param.mode = mode;

  629.         cur_param.nonlineMode = nlmode;

  630. 

  631.         cur_param.format = param::ConvBias::Format::NCHW4;

  632.         cur_param.sparse = param::ConvBias::Sparse::DENSE;

  633.         cur_param.pad_h = cur_param.pad_w = p;

  634.         cur_param.stride_h = cur_param.stride_w = s;

  635. 

  636.         //! bias channel

  637.         args.emplace_back(cur_param, TensorShape{b, ic / 4, h, w, 4},

  638.                           TensorShape{oc, ic / 4, f, f, 4},

  639.                           TensorShape{1, oc / 4, 1, 1, 4});

  640.     } } } } } } } } }

  641.     // clang-format on

  642.     return args;

  643. }

  644. 

  645. std::vector<TestArg> get_int8_chwn4_args(size_t kernel_size) {

  646.     auto args = get_int8_nchw4_args(kernel_size);

  647.     for (auto& arg : args) {

  648.         convert_arg_from_nchw4_to_chwn4(arg);

  649.     }

  650.     return args;

  651. }

  652. 

  653. std::vector<TestArg> get_int8_chwn4_args_check_bounds(size_t kernel_size) {

  654.     auto args = get_int8_nchw4_args_check_bounds(kernel_size);

  655.     for (auto& arg : args) {

  656.         convert_arg_from_nchw4_to_chwn4(arg);

  657.     }

  658.     return args;

  659. }

  660. 

  661. std::vector<TestArg> get_int8_chwn4_small_channel_args(size_t kernel_size) {

  662.     auto args = get_int8_nchw4_small_channel_args(kernel_size);

  663.     for (auto& arg : args) {

  664.         convert_arg_from_nchw4_to_chwn4(arg);

  665.     }

  666.     return args;

  667. }

  668. 

  669. std::vector<TestArg> get_int8_chwn4_small_channel_args_check_bounds(

  670.         size_t kernel_size) {

  671.     auto args = get_int8_nchw4_small_channel_args_check_bounds(kernel_size);

  672.     for (auto& arg : args) {

  673.         convert_arg_from_nchw4_to_chwn4(arg);

  674.     }

  675.     return args;

  676. }

  677. 

  678. std::vector<TestArg> get_int8_chwn4_args_small_batch(size_t kernel_size) {

  679.     auto args = get_int8_nchw4_args_small_batch(kernel_size);

  680.     for (auto& arg : args) {

  681.         convert_arg_from_nchw4_to_chwn4(arg);

  682.     }

  683.     return args;

  684. }

  685. 

  686. std::vector<TestArg> get_int8_nchw4_tensorcore_args(size_t kernel_size) {

  687.     std::vector<TestArg> args;

  688.     param::ConvBias cur_param;

  689. 

  690.     using NLMode = param::ConvBias::NonlineMode;

  691. 

  692.     // clang-format off

  693.     for (auto nlmode : {NLMode::IDENTITY, NLMode::RELU}) {

  694.     for (auto mode : {param::ConvBias::Mode::CROSS_CORRELATION}) {

  695.         size_t b = 64, oc = 128;

  696.         for (size_t ic : {32, 64}) {

  697.         for (size_t h : {8}) {

  698.         for (size_t w : {11}) {

  699.         for (int p : {static_cast<int>(kernel_size / 2), 0}) {

  700.         for (size_t s : {1, 2}) {

  701.             size_t f = kernel_size;

  702.             cur_param.mode = mode;

  703.             cur_param.nonlineMode = nlmode;

  704. 

  705.             cur_param.format = param::ConvBias::Format::NCHW4;

  706.             cur_param.sparse = param::ConvBias::Sparse::DENSE;

  707.             cur_param.pad_h = cur_param.pad_w = p;

  708.             cur_param.stride_h = cur_param.stride_w = s;

  709. 

  710.             //! bias channel

  711.             args.emplace_back(cur_param, TensorShape{b, ic / 4, h, w, 4},

  712.                               TensorShape{oc, ic / 4, f, f, 4},

  713.                               TensorShape{1, oc / 4, 1, 1, 4});

  714.         } } } } }

  715.     } }

  716.     // clang-format on

  717. 

  718.     return args;

  719. }

  720. 

  721. std::vector<TestArg> get_int8_chwn4_tensorcore_args(size_t kernel_size) {

  722.     auto args = get_int8_nchw4_tensorcore_args(kernel_size);

  723.     for (auto& arg : args) {

  724.         convert_arg_from_nchw4_to_chwn4(arg);

  725.     }

  726.     return args;

  727. }

  728. 

  729. void check_conv_bias(DType src_dtype, DType filter_dtype, DType bias_dtype,

  730.                      DType dst_dtype, Handle* handle, const char* algo,

  731.                      param::ConvBias::Format format,

  732.                      const std::vector<TestArg>& args, bool fuse_z,

  733.                      bool stable_test) {

  734.     megdnn_assert((src_dtype.enumv() == filter_dtype.enumv()) ||

  735.                   (src_dtype.enumv() == DTypeEnum::Quantized4Asymm &&

  736.                    filter_dtype.enumv() == DTypeEnum::QuantizedS4));

  737.     Checker<ConvBiasForward> checker(handle, !stable_test);

  738.     if (algo) {

  739.         checker.set_before_exec_callback(

  740.                 ConvBiasAlgoChecker<ConvBiasForward>(algo));

  741.     }

  742.     std::unique_ptr<RNG> rng;

  743.     std::unique_ptr<RNG> flt_rng;

  744.     std::unique_ptr<RNG> bias_rng;

  745.     std::unique_ptr<RNG> const_rng;

  746.     std::unique_ptr<RNG> zero_rng;

  747.     // TODO: check range of rng

  748.     if (src_dtype.enumv() == DTypeEnum::QuantizedS8) {

  749.         rng = std::make_unique<UniformIntRNG>(-3, 3);

  750.         flt_rng = std::make_unique<UniformIntRNG>(-3, 3);

  751.         const_rng = std::make_unique<UniformIntRNG>(1, 1);

  752.         zero_rng = std::make_unique<UniformIntRNG>(0, 0);

  753.         megdnn_assert(bias_dtype.enumv() == DTypeEnum::QuantizedS32);

  754.         bias_rng = std::make_unique<UniformIntRNG>(-50, 50);

  755.         checker.set_epsilon(1 + 1e-3)

  756.                 .set_max_avg_error(1e-1)

  757.                 .set_max_avg_biased_error(1e-3);

  758.     } else if (src_dtype.enumv() == DTypeEnum::Quantized4Asymm) {

  759.         rng = std::make_unique<UniformIntRNG>(0, 6);

  760.         flt_rng = std::make_unique<UniformIntRNG>(-3, 3);

  761.         const_rng = std::make_unique<UniformIntRNG>(1, 1);

  762.         zero_rng = std::make_unique<UniformIntRNG>(0, 0);

  763.         megdnn_assert(bias_dtype.enumv() == DTypeEnum::QuantizedS32);

  764.         bias_rng = std::make_unique<UniformIntRNG>(-50, 50);

  765.         checker.set_epsilon(1 + 1e-3)

  766.                 .set_max_avg_error(1e-1)

  767.                 .set_max_avg_biased_error(1e-3);

  768.     } else if (src_dtype.enumv() == DTypeEnum::QuantizedS4) {

  769.         rng = std::make_unique<UniformIntRNG>(-3, 3);

  770.         flt_rng = std::make_unique<UniformIntRNG>(-3, 3);

  771.         const_rng = std::make_unique<UniformIntRNG>(1, 1);

  772.         zero_rng = std::make_unique<UniformIntRNG>(0, 0);

  773.         megdnn_assert(bias_dtype.enumv() == DTypeEnum::QuantizedS32);

  774.         bias_rng = std::make_unique<UniformIntRNG>(-50, 50);

  775.         checker.set_epsilon(1 + 1e-3)

  776.                 .set_max_avg_error(1e-1)

  777.                 .set_max_avg_biased_error(1e-3);

  778.     } else if (src_dtype.enumv() == DTypeEnum::Float16) {

  779.         rng = std::make_unique<NormalRNG>(2.f);

  780.         flt_rng = std::make_unique<NormalRNG>(2.f);

  781.         megdnn_assert(bias_dtype.enumv() == DTypeEnum::Float16);

  782.         bias_rng = std::make_unique<NormalRNG>(2.f);

  783.         checker.set_epsilon(1e-2);

  784.     } else if (src_dtype.enumv() == DTypeEnum::Float32) {

  785.         rng = std::make_unique<NormalRNG>(2.f);

  786.         flt_rng = std::make_unique<NormalRNG>(2.f);

  787.         megdnn_assert(bias_dtype.enumv() == DTypeEnum::Float32);

  788.         bias_rng = std::make_unique<NormalRNG>(2.f);

  789.     }

  790. 

  791.     using Param = param::ConvBias;

  792.     using Format = Param::Format;

  793.     auto get_z_shape = [&fuse_z, &format](TestArg arg) -> TensorShape {

  794.         TensorShape z{};

  795.         if (fuse_z) {

  796.             size_t hi, wi, sh, sw, ph, pw, fh, fw;

  797.             z = arg.src;

  798.             size_t spatial_idx = 2;

  799.             if (format == Format::NCHW4) {

  800.                 hi = arg.src[2];

  801.                 wi = arg.src[3];

  802.                 fh = arg.filter[2];

  803.                 fw = arg.filter[3];

  804.                 z[1] = arg.filter[0] / 4;

  805.             } else if (format == Format::NCHW32) {

  806.                 hi = arg.src[2];

  807.                 wi = arg.src[3];

  808.                 fh = arg.filter[2];

  809.                 fw = arg.filter[3];

  810.                 z[1] = arg.filter[0] / 32;

  811.             } else if (format == Format::NCHW64) {

  812.                 hi = arg.src[2];

  813.                 wi = arg.src[3];

  814.                 fh = arg.filter[2];

  815.                 fw = arg.filter[3];

  816.                 z[1] = arg.filter[0] / 64;

  817.             } else {

  818.                 megdnn_assert(format == Format::CHWN4);

  819.                 hi = arg.src[1];

  820.                 wi = arg.src[2];

  821.                 fh = arg.filter[1];

  822.                 fw = arg.filter[2];

  823.                 z[0] = arg.filter[3] / 4;

  824.                 spatial_idx = 1;

  825.             }

  826.             sh = arg.param.stride_h;

  827.             sw = arg.param.stride_w;

  828.             ph = arg.param.pad_h;

  829.             pw = arg.param.pad_w;

  830.             size_t ho = infer_conv_shape(hi, fh, sh, ph);

  831.             size_t wo = infer_conv_shape(wi, fw, sw, pw);

  832.             z[spatial_idx] = ho;

  833.             z[spatial_idx + 1] = wo;

  834.         }

  835.         return z;

  836.     };

  837.     megdnn_assert(rng != nullptr && flt_rng != nullptr && bias_rng != nullptr);

  838.     checker.set_rng(0, rng.get())

  839.             .set_rng(1, flt_rng.get())

  840.             .set_rng(2, bias_rng.get())

  841.             .set_rng(3, rng.get());

  842.     if (stable_test) {

  843.         checker.set_stable_check(true);

  844.         checker.set_no_naive_check(true);

  845.     }

  846.     if (args.empty()) {

  847.         std::vector<TestArg> default_args;

  848.         if (format == Format::NCHW4) {

  849.             default_args = get_int8_nchw4_args(3);

  850.         } else if (format == Format::CHWN4) {

  851.             default_args = get_int8_chwn4_args(3);

  852.         }

  853.         for (auto&& arg : default_args) {

  854.             auto z = get_z_shape(arg);

  855.             checker.set_dtype(0, src_dtype)

  856.                     .set_dtype(1, filter_dtype)

  857.                     .set_dtype(2, bias_dtype)

  858.                     .set_dtype(3, dst_dtype)

  859.                     .set_dtype(4, dst_dtype)

  860.                     .set_param(arg.param)

  861.                     .execs({arg.src, arg.filter, arg.bias, z, {}});

  862.         }

  863.     } else {

  864.         for (auto&& arg : args) {

  865.             auto z = get_z_shape(arg);

  866.             checker.set_dtype(0, src_dtype)

  867.                     .set_dtype(1, filter_dtype)

  868.                     .set_dtype(2, bias_dtype)

  869.                     .set_dtype(3, dst_dtype)

  870.                     .set_dtype(4, dst_dtype)

  871.                     .set_param(arg.param)

  872.                     .execs({arg.src, arg.filter, arg.bias, z, {}});

  873.         }

  874.     }

  875. }

  876. #if MEGDNN_WITH_BENCHMARK

  877. std::vector<conv_bias::TestArg> get_winograd_benchmark_args(size_t kernel,

  878.                                                             size_t pack_size) {

  879.     std::vector<conv_bias::TestArg> args;

  880.     auto pack = [&](size_t oc, size_t ic, size_t w, size_t h, size_t kernel,

  881.                     size_t p) {

  882.         if (ic % pack_size != 0 || oc % pack_size != 0)

  883.             return;

  884.         if (w + 2 * p < kernel || h + 2 * p < kernel)

  885.             return;

  886.         param::ConvBias param;

  887.         param.stride_h = 1;

  888.         param.stride_w = 1;

  889.         param.pad_h = p;

  890.         param.pad_w = p;

  891. 

  892.         args.push_back(conv_bias::TestArg{param,

  893.                                           TensorShape{1, ic, h, w},

  894.                                           TensorShape{oc, ic, kernel, kernel},

  895.                                           {1, oc, 1, 1}});

  896.     };

  897.     for (size_t ic : {8, 16, 32, 64}) {

  898.         for (size_t oc : {8, 16, 32, 64}) {

  899.             pack(oc, ic, 56, 56, kernel, kernel / 2);

  900.             pack(oc, ic, 128, 128, kernel, kernel / 2);

  901.             pack(oc, ic, 256, 256, kernel, kernel / 2);

  902.         }

  903.     }

  904. 

  905.     //! conv in vgg16

  906.     pack(512, 512, 15, 15, kernel, kernel / 2);

  907.     pack(512, 256, 15, 15, kernel, kernel / 2);

  908.     pack(256, 256, 29, 29, kernel, kernel / 2);

  909.     pack(256, 128, 29, 29, kernel, kernel / 2);

  910.     pack(128, 128, 57, 57, kernel, kernel / 2);

  911.     pack(128, 64, 57, 57, kernel, kernel / 2);

  912.     pack(64, 64, 123, 123, kernel, kernel / 2);

  913.     pack(64, 24, 123, 123, kernel, kernel / 2);

  914.     pack(24, 24, 224, 224, kernel, kernel / 2);

  915. 

  916.     //! conv in resnet18

  917.     pack(64, 64, 56, 56, kernel, kernel / 2);

  918.     pack(128, 128, 28, 28, kernel, kernel / 2);

  919.     pack(256, 256, 14, 14, kernel, kernel / 2);

  920.     pack(512, 512, 7, 7, kernel, kernel / 2);

  921.     return args;

  922. }

  923. 

  924. void benchmark_winograd(const char* algo_name, Handle* handle, size_t kernel,

  925.                         size_t pack_size) {

  926.     auto&& args = get_winograd_benchmark_args(kernel, pack_size);

  927.     using namespace conv_bias;

  928.     constexpr size_t RUN = 10;

  929.     Benchmarker<Convolution> benchmark(handle);

  930.     benchmark.set_display(false);

  931.     benchmark.set_times(RUN);

  932. 

  933.     Benchmarker<ConvBias> benchmark_winograd(handle);

  934.     benchmark_winograd.set_display(false);

  935.     benchmark_winograd.set_times(RUN);

  936. 

  937.     for (auto&& arg : args) {

  938.         TensorLayout dst_layout;

  939.         auto opr = handle->create_operator<ConvBias>();

  940.         opr->param() = arg.param;

  941.         opr->deduce_layout({arg.src, dtype::Float32()},

  942.                            {arg.filter, dtype::Float32()},

  943.                            {arg.bias, dtype::Float32()}, {}, dst_layout);

  944.         //! dst.nr_elems * IC * FH * FW * 2

  945.         float computations = dst_layout.total_nr_elems() * arg.filter[1] *

  946.                              arg.filter[2] * arg.filter[3] * 2.0 /

  947.                              (1024 * 1024 * 1024) * 1e3;

  948. 

  949.         param::Convolution conv_param;

  950.         conv_param.pad_h = arg.param.pad_h;

  951.         conv_param.pad_w = arg.param.pad_w;

  952.         conv_param.stride_h = arg.param.stride_h;

  953.         conv_param.stride_w = arg.param.stride_w;

  954.         auto used = benchmark.set_param(conv_param)

  955.                             .exec({arg.src, arg.filter, {}}) /

  956.                     RUN;

  957. 

  958.         benchmark_winograd.set_param(arg.param);

  959.         auto used_winograd =

  960.                 algo_benchmark<ConvBias>(benchmark_winograd,

  961.                                          {arg.src, arg.filter, {}, {}, {}},

  962.                                          algo_name) /

  963.                 RUN;

  964. 

  965.         printf("%s %s: normal: %f ms %f Gflops winograd: %f ms %f GFlops "

  966.                "speedup: "

  967.                "%f\n",

  968.                arg.src.to_string().c_str(), arg.filter.to_string().c_str(),

  969.                used, computations / used, used_winograd,

  970.                computations / used_winograd, used / used_winograd);

  971.     }

  972. }

  973. #endif  // MEGDNN_WITH_BENCHMARK

  974. 

  975. std::vector<conv_bias::TestArg> get_conv_bias_args(

  976.         std::vector<size_t> kernel, size_t stride, bool no_pad, bool no_bias,

  977.         bool no_nonlinemode, bool quantized_nlmod, bool only_broadcast_bias) {

  978.     using namespace conv_bias;

  979.     using Param = param::ConvBias;

  980.     using NLMode = param::ConvBias::NonlineMode;

  981.     std::vector<TestArg> args;

  982. 

  983.     auto pack = [&](size_t n, size_t oc, size_t ic, size_t w, size_t h,

  984.                     size_t kernel, size_t stride, NLMode nlmode) {

  985.         Param param;

  986.         param.stride_h = stride;

  987.         param.stride_w = stride;

  988.         if (!no_pad) {

  989.             param.pad_h = kernel / 2;

  990.             param.pad_w = kernel / 2;

  991.         } else {

  992.             param.pad_h = 0;

  993.             param.pad_w = 0;

  994.         }

  995.         param.nonlineMode = nlmode;

  996. 

  997.         args.emplace_back(param, TensorShape{n, ic, h, w},

  998.                           TensorShape{oc, ic, kernel, kernel}, TensorShape{});

  999.         if (!no_bias) {

  1000.             args.emplace_back(param, TensorShape{n, ic, h, w},

  1001.                               TensorShape{oc, ic, kernel, kernel},

  1002.                               TensorShape{1, oc, 1, 1});

  1003. 

  1004.             if (!only_broadcast_bias) {

  1005.                 args.emplace_back(

  1006.                         param, TensorShape{n, ic, h, w},

  1007.                         TensorShape{oc, ic, kernel, kernel},

  1008.                         TensorShape{

  1009.                                 n, oc,

  1010.                                 (h + 2 * param.pad_h - kernel) / stride + 1,

  1011.                                 (w + 2 * param.pad_h - kernel) / stride + 1});

  1012.             }

  1013.         }

  1014.         param.sparse = param::ConvBias::Sparse::GROUP;

  1015.         args.emplace_back(param, TensorShape{n, 2 * ic, h, w},

  1016.                           TensorShape{2, oc, ic, kernel, kernel},

  1017.                           TensorShape{});

  1018.         if (!no_bias) {

  1019.             if (!only_broadcast_bias) {

  1020.                 args.emplace_back(

  1021.                         param, TensorShape{n, 2 * ic, h, w},

  1022.                         TensorShape{2, oc, ic, kernel, kernel},

  1023.                         TensorShape{

  1024.                                 n, 2 * oc,

  1025.                                 (h + param.pad_h * 2 - kernel) / stride + 1,

  1026.                                 (w + param.pad_w * 2 - kernel) / stride + 1});

  1027.             }

  1028.             args.emplace_back(param, TensorShape{n, 2 * ic, h, w},

  1029.                               TensorShape{2, oc, ic, kernel, kernel},

  1030.                               TensorShape{1, 2 * oc, 1, 1});

  1031.         }

  1032.     };

  1033. 

  1034.     std::vector<NLMode> nonlinemode = {NLMode::IDENTITY};

  1035.     if (!no_nonlinemode) {

  1036.         nonlinemode.emplace_back(NLMode::RELU);

  1037.         nonlinemode.emplace_back(NLMode::H_SWISH);

  1038.         if (!quantized_nlmod) {

  1039.             nonlinemode.emplace_back(NLMode::SIGMOID);

  1040.         }

  1041.     }

  1042. 

  1043.     for (size_t n : {1, 2}) {

  1044.         for (auto nlmode : nonlinemode) {

  1045.             for (size_t ic : {1, 3, 7}) {

  1046.                 for (size_t oc : {1, 3, 7}) {

  1047.                     for (size_t size : {8, 16, 20}) {

  1048.                         for (size_t kern : kernel) {

  1049.                             pack(n, oc, ic, size, size, kern, stride, nlmode);

  1050.                         }

  1051.                     }

  1052.                 }

  1053.             }

  1054.         }

  1055.     }

  1056.     return args;

  1057. }

  1058. 

  1059. std::vector<megdnn::test::conv_bias::TestArg> get_conv_bias_1x1_args(

  1060.         bool no_bias, bool no_nonlinemode, bool quantized_nlmod,

  1061.         bool only_broadcast_bias) {

  1062.     using namespace conv_bias;

  1063.     using Param = param::ConvBias;

  1064.     using NLMode = param::ConvBias::NonlineMode;

  1065.     using CONVMode = param::ConvBias::Mode;

  1066.     std::vector<TestArg> args;

  1067. 

  1068.     auto pack = [&](size_t n, size_t oc, size_t ic, size_t w, size_t h,

  1069.                     size_t stride, NLMode nlmode, CONVMode convmode) {

  1070.         Param param;

  1071.         param.stride_h = stride;

  1072.         param.stride_w = stride;

  1073.         param.pad_h = 0;

  1074.         param.pad_w = 0;

  1075. 

  1076.         param.mode = convmode;

  1077.         param.nonlineMode = nlmode;

  1078. 

  1079.         args.emplace_back(param, TensorShape{n, ic, h, w},

  1080.                           TensorShape{oc, ic, 1, 1}, TensorShape{});

  1081.         if (!no_bias) {

  1082.             args.emplace_back(param, TensorShape{n, ic, h, w},

  1083.                               TensorShape{oc, ic, 1, 1},

  1084.                               TensorShape{1, oc, 1, 1});

  1085. 

  1086.             if (!only_broadcast_bias) {

  1087.                 args.emplace_back(param, TensorShape{n, ic, h, w},

  1088.                                   TensorShape{oc, ic, 1, 1},

  1089.                                   TensorShape{n, oc, (h - 1) / stride + 1,

  1090.                                               (w - 1) / stride + 1});

  1091.             }

  1092.         }

  1093. 

  1094.         param.sparse = param::ConvBias::Sparse::GROUP;

  1095. 

  1096.         args.emplace_back(param, TensorShape{n, 2 * ic, h, w},

  1097.                           TensorShape{2, oc, ic, 1, 1}, TensorShape{});

  1098.         if (!no_bias) {

  1099.             args.emplace_back(param, TensorShape{n, 2 * ic, h, w},

  1100.                               TensorShape{2, oc, ic, 1, 1},

  1101.                               TensorShape{1, 2 * oc, 1, 1});

  1102. 

  1103.             if (!only_broadcast_bias) {

  1104.                 args.emplace_back(param, TensorShape{n, 2 * ic, h, w},

  1105.                                   TensorShape{2, oc, ic, 1, 1},

  1106.                                   TensorShape{n, 2 * oc, (h - 1) / stride + 1,

  1107.                                               (w - 1) / stride + 1});

  1108.             }

  1109.         }

  1110.     };

  1111. 

  1112.     std::vector<NLMode> nonlinemode = {NLMode::IDENTITY};

  1113.     if (!no_nonlinemode) {

  1114.         nonlinemode.emplace_back(NLMode::RELU);

  1115.         nonlinemode.emplace_back(NLMode::H_SWISH);

  1116.         if (!quantized_nlmod) {

  1117.             nonlinemode.emplace_back(NLMode::SIGMOID);

  1118.         }

  1119.     }

  1120. 

  1121.     std::vector<CONVMode> convmodes{param::ConvBias::Mode::CONVOLUTION,

  1122.                                     param::ConvBias::Mode::CROSS_CORRELATION};

  1123. 

  1124.     for (size_t n : {1, 2})

  1125.         for (size_t oc : {1, 9, 33})

  1126.             for (size_t ic : {1, 16, 64})

  1127.                 for (size_t size : {1, 7, 14, 28})

  1128.                     for (auto nlmode : nonlinemode)

  1129.                         for (auto convmode : convmodes) {

  1130.                             pack(n, oc, ic, size, size, 1, nlmode, convmode);

  1131.                         }

  1132.     return args;

  1133. }

  1134. 

  1135. void check_conv_bias(std::vector<conv_bias::TestArg> args, Handle* handle,

  1136.                      const char* algo_name) {

  1137.     using namespace conv_bias;

  1138. 

  1139.     Checker<ConvBias> checker(handle);

  1140.     checker.set_before_exec_callback(

  1141.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

  1142.     for (auto&& arg : args) {

  1143.         checker.set_param(arg.param).execs(

  1144.                 {arg.src, arg.filter, arg.bias, {}, {}});

  1145.     }

  1146. }

  1147. 

  1148. void checker_conv_bias_int8x8x16(std::vector<conv_bias::TestArg> args,

  1149.                                  Handle* handle, const char* algo_name) {

  1150.     using namespace conv_bias;

  1151. 

  1152.     Checker<ConvBias> checker(handle);

  1153.     checker.set_before_exec_callback(

  1154.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

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

  1156.     checker.set_dtype(1, dtype::Int8());

  1157.     checker.set_dtype(2, dtype::Int16());

  1158.     checker.set_dtype(4, dtype::Int16());

  1159.     for (auto&& arg : args) {

  1160.         checker.set_param(arg.param).execs({arg.src, arg.filter, {}, {}, {}});

  1161.     }

  1162. }

  1163. 

  1164. void check_conv_bias_preprocess(std::vector<conv_bias::TestArg> args,

  1165.                                 Handle* handle, RNG* rng, float epsilon,

  1166.                                 DType type0, DType type1, DType type2,

  1167.                                 DType type3, const char* algo_name) {

  1168.     using namespace conv_bias;

  1169. 

  1170.     Checker<ConvBiasForward, OprWeightPreprocessProxy<ConvBiasForward>> checker(

  1171.             handle);

  1172.     checker.set_dtype(0, type0);

  1173.     checker.set_dtype(1, type1);

  1174.     checker.set_dtype(2, type2);

  1175.     checker.set_dtype(4, type3);

  1176.     checker.set_epsilon(epsilon);

  1177.     if (NULL != rng) {

  1178.         checker.set_rng(0, rng).set_rng(1, rng).set_rng(2, rng).set_rng(3, rng);

  1179.     }

  1180.     checker.set_before_exec_callback(

  1181.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

  1182.     for (auto&& arg : args) {

  1183.         checker.set_param(arg.param).execs(

  1184.                 {arg.src, arg.filter, arg.bias, {}, {}});

  1185.     }

  1186. }

  1187. 

  1188. void checker_conv_bias_common(std::vector<conv_bias::TestArg> args, Handle* handle,

  1189.                        RNG* rng, float epsilon, DType type0, DType type1,

  1190.                        DType type2, DType type3, const char* algo_name) {

  1191.     using namespace conv_bias;

  1192. 

  1193.     Checker<ConvBias> checker(handle);

  1194.     checker.set_before_exec_callback(

  1195.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

  1196.     checker.set_dtype(0, type0);

  1197.     checker.set_dtype(1, type1);

  1198.     checker.set_dtype(2, type2);

  1199.     checker.set_dtype(4, type3);

  1200.     checker.set_epsilon(epsilon);

  1201.     if (NULL != rng) {

  1202.         checker.set_rng(0, rng).set_rng(1, rng).set_rng(2, rng).set_rng(3, rng);

  1203.     }

  1204.     for (auto&& arg : args) {

  1205.         checker.set_param(arg.param).execs(

  1206.                 {arg.src, arg.filter, arg.bias, {}, {}});

  1207.     }

  1208. }

  1209. 

  1210. void checker_conv_bias_mul_int8x8x32(std::vector<conv_bias::TestArg> args,

  1211.                                      Handle* handle, const char* algo_name) {

  1212.     using namespace conv_bias;

  1213.     float epsilon = 0.001;

  1214. #if MEGDNN_ARMV7

  1215.     epsilon = 1.0;

  1216. #endif

  1217.     Checker<ConvBias> checker(handle);

  1218.     checker.set_before_exec_callback(

  1219.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

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

  1221.     checker.set_dtype(1, dtype::Int8());

  1222.     checker.set_dtype(2, dtype::Int32());

  1223.     checker.set_dtype(4, dtype::Int32());

  1224.     checker.set_epsilon(epsilon);

  1225.     for (auto&& arg : args) {

  1226.         checker.set_param(arg.param).execs({arg.src, arg.filter, {}, {}, {}});

  1227.     }

  1228. 

  1229.     UniformIntRNG rng{-50, 50};

  1230.     for (auto&& arg : args) {

  1231.         checker.set_dtype(0, dtype::QuantizedS8(2.5f))

  1232.                 .set_dtype(1, dtype::QuantizedS8(2.5f))

  1233.                 .set_dtype(2, dtype::QuantizedS32(6.25f))

  1234.                 .set_dtype(4, dtype::QuantizedS32(6.25f))

  1235.                 .set_rng(0, &rng)

  1236.                 .set_rng(1, &rng)

  1237.                 .set_rng(2, &rng)

  1238.                 .set_param(arg.param)

  1239.                 .set_epsilon(epsilon)

  1240.                 .execs({arg.src, arg.filter, {}, {}, {}});

  1241.     }

  1242. }

  1243. 

  1244. void checker_conv_bias_int8x8x32_preprocess(

  1245.         std::vector<conv_bias::TestArg> args, Handle* handle,

  1246.         const char* algo_name) {

  1247.     using namespace conv_bias;

  1248. 

  1249.     Checker<ConvBiasForward, OprWeightPreprocessProxy<ConvBiasForward>> checker(

  1250.             handle);

  1251.     checker.set_before_exec_callback(

  1252.             conv_bias::ConvBiasAlgoChecker<ConvBias>(algo_name));

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

  1254.     checker.set_dtype(1, dtype::Int8());

  1255.     checker.set_dtype(2, dtype::Int32());

  1256.     checker.set_dtype(4, dtype::Int32());

  1257.     for (auto&& arg : args) {

  1258.         checker.set_param(arg.param).execs({arg.src, arg.filter, {}, {}, {}});

  1259.     }

  1260. 

  1261.     UniformIntRNG rng{-50, 50};

  1262.     for (auto&& arg : args) {

  1263.         checker.set_dtype(0, dtype::QuantizedS8(2.5f))

  1264.                 .set_dtype(1, dtype::QuantizedS8(2.5f))

  1265.                 .set_dtype(2, dtype::QuantizedS32(6.25f))

  1266.                 .set_dtype(4, dtype::QuantizedS32(6.25f))

  1267.                 .set_rng(0, &rng)

  1268.                 .set_rng(1, &rng)

  1269.                 .set_rng(2, &rng)

  1270.                 .set_param(arg.param)

  1271.                 .execs({arg.src, arg.filter, {}, {}, {}});

  1272.     }

  1273. }

  1274. 

  1275. std::vector<conv_bias::TestArg> get_nchw44_conv_bias_args(

  1276.         std::vector<size_t> kernel_vec,

  1277.         std::vector<param::ConvBias::NonlineMode> nlmode_vec,

  1278.         std::vector<megdnn::BiasMode> biasmode_vec, size_t stride, bool no_pad,

  1279.         bool is_input_nchw, bool is_nchw44_dot) {

  1280.     using namespace conv_bias;

  1281.     using NLMode = param::ConvBias::NonlineMode;

  1282. 

  1283.     std::vector<TestArg> args;

  1284.     MEGDNN_MARK_USED_VAR(no_pad);

  1285. 

  1286.     auto pack = [&](size_t n, size_t oc, size_t ic, size_t h, size_t w,

  1287.                     size_t kernel, size_t stride, size_t group, NLMode nlmode,

  1288.                     megdnn::BiasMode bias_mode, int any_pad = -1) {

  1289.         constexpr int pack_c = 4;

  1290.         const size_t pad = any_pad >= 0 ? any_pad : kernel / 2;

  1291.         auto oc_per_group = oc / group;

  1292.         auto ic_per_group = ic / group;

  1293.         bool ok_group = (oc % group == 0 && ic % group == 0) &&

  1294.                         oc_per_group % pack_c == 0 && oc_per_group > 0 &&

  1295.                         ic_per_group > 0;

  1296.         bool nchw_disable = group > 1 || ic_per_group >= 4;

  1297.         bool nchw44_disable = ic_per_group % pack_c != 0;

  1298.         bool invalid_pad = (w + 2 * pad < kernel) || (h + 2 * pad < kernel);

  1299.         if (!(ok_group) || invalid_pad) {

  1300.             return;

  1301.         }

  1302.         if ((is_input_nchw && nchw_disable) ||

  1303.             (!is_input_nchw && nchw44_disable)) {

  1304.             return;

  1305.         }

  1306. 

  1307.         size_t kernel_h = kernel;

  1308.         size_t kernel_w = kernel;

  1309.         param::ConvBias param;

  1310.         if (!is_nchw44_dot) {

  1311.             param.format = param::ConvBias::Format::NCHW44;

  1312.         } else {

  1313.             param.format = param::ConvBias::Format::NCHW44_DOT;

  1314.         }

  1315.         param.stride_h = stride;

  1316.         param.stride_w = stride;

  1317.         param.pad_h = pad;

  1318.         param.pad_w = pad;

  1319.         param.nonlineMode = nlmode;

  1320. 

  1321.         auto src_tensor_shape = TensorShape{n, ic / pack_c, h, w, pack_c};

  1322.         auto weight_tensor_shape = TensorShape{

  1323.                 oc / pack_c, ic / pack_c, kernel_h, kernel_w, pack_c, pack_c};

  1324.         auto bias_tensor_shape = TensorShape{};

  1325.         if (bias_mode == megdnn::BiasMode::BROADCAST_CHANNEL_BIAS) {

  1326.             bias_tensor_shape = {1, oc / pack_c, 1, 1, pack_c};

  1327.         } else if (bias_mode == megdnn::BiasMode::BIAS) {

  1328.             bias_tensor_shape = {n, oc / pack_c,

  1329.                                  (h + 2 * pad - kernel) / stride + 1,

  1330.                                  (w + 2 * pad - kernel) / stride + 1, pack_c};

  1331.         }

  1332.         if (group == 1) {

  1333.             param.sparse = param::ConvBias::Sparse::DENSE;

  1334.         } else if (group > 1 && ic / group == 1 && oc / group == 1) {

  1335.             megdnn_assert(0, "not support channel wise");

  1336.             param.sparse = param::ConvBias::Sparse::GROUP;

  1337.             weight_tensor_shape = TensorShape{group / pack_c, 1,        1,

  1338.                                               kernel_h,       kernel_w, pack_c};

  1339.         } else if (group > 1 && oc_per_group % pack_c == 0 && oc / group > 0 &&

  1340.                    ic_per_group % pack_c == 0 && ic / group > 0) {

  1341.             param.sparse = param::ConvBias::Sparse::GROUP;

  1342.             weight_tensor_shape = TensorShape{group,

  1343.                                               oc_per_group / pack_c,

  1344.                                               ic_per_group / pack_c,

  1345.                                               kernel_h,

  1346.                                               kernel_w,

  1347.                                               pack_c,

  1348.                                               pack_c};

  1349.         }

  1350.         if (is_input_nchw) {

  1351.             src_tensor_shape = TensorShape{n, ic, h, w};

  1352.             weight_tensor_shape =

  1353.                     TensorShape{oc / pack_c, kernel_h, kernel_w, ic, pack_c};

  1354.         }

  1355.         args.emplace_back(param, src_tensor_shape, weight_tensor_shape,

  1356.                           bias_tensor_shape);

  1357.     };

  1358. 

  1359.     for (auto bias : biasmode_vec)

  1360.         for (auto nlmode : nlmode_vec)

  1361.             for (size_t n : {1, 2})

  1362.                 for (size_t kernel : kernel_vec)

  1363.                     for (size_t oc : {4, 12})

  1364.                         for (size_t ic : {1, 3, 4, 12})

  1365.                             for (size_t h : {1, 3, 12})

  1366.                                 for (size_t w : {1, 16, 23}) {

  1367.                                     for (size_t group = 1;

  1368.                                          group <=

  1369.                                          std::min(std::min(oc, ic), 4_z);

  1370.                                          ++group) {

  1371.                                         if (kernel != 1 && (h == 1 || w == 1)) {

  1372.                                             continue;

  1373.                                         }

  1374.                                         pack(n, oc, ic, h, w, kernel, stride,

  1375.                                              group, nlmode, bias);

  1376.                                     }

  1377.                                 }

  1378.     return args;

  1379. }

  1380. }  // namespace conv_bias

  1381. }  // namespace test

  1382. }  // namespace megdnn

  1383. 

  1384. // vim: syntax=cpp.doxygen