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: 1e71e0afe0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1e71e0afe0'
${ noResults }
MegEngine/dnn/test/fallback/convolution.cpp

668 lines
26 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/fallback/convolution.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

  10.  * implied.

  11.  */

  12. #include "megdnn/dtype.h"

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

  14. 

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

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

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

  18. 

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

  20. 

  21. using namespace megdnn;

  22. using namespace test;

  23. 

  24. #if MEGDNN_WITH_BENCHMARK

  25. 

  26. TEST_F(FALLBACK, BENCHMARK_CONVOLUTION_MATRIX_MUL) {

  27.     using Param = Convolution::Param;

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

  29.         Benchmarker<Convolution> benchmarker_float(handle());

  30.         size_t RUN = 50;

  31.         auto tfloat = benchmarker_float.set_display(false)

  32.                               .set_dtype(0, dtype::Float32{})

  33.                               .set_dtype(1, dtype::Float32{})

  34.                               .set_times(RUN)

  35.                               .set_param(param)

  36.                               .exec(shapes);

  37.         size_t IC = shapes[1][1];

  38.         size_t FH = shapes[1][2];

  39.         size_t FW = shapes[1][3];

  40.         TensorLayout dst_layout;

  41.         auto opr = handle()->create_operator<Convolution>();

  42.         opr->param() = param;

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

  44.                            {shapes[1], dtype::Float32()}, dst_layout);

  45.         printf("fp32 flops: %.3f mflops\n",

  46.                (IC * dst_layout.total_nr_elems() * FH * FW * 2) /

  47.                        (tfloat / RUN * 1000));

  48.     };

  49.     auto profile = [&](size_t oc, size_t ic, size_t w, size_t h, size_t kernel,

  50.                        size_t stride) {

  51.         Param param;

  52.         param.stride_h = stride;

  53.         param.stride_w = stride;

  54.         param.pad_h = kernel / 2;

  55.         param.pad_w = kernel / 2;

  56.         param.pad_h = 0;

  57.         param.pad_w = 0;

  58.         printf("oc: %zd ic: %zd w: %zd h: %zd stride: %zd kernel_size: %zd\n",

  59.                oc, ic, w, h, stride, kernel);

  60. 

  61.         run({{1, ic, h, w}, {oc, ic, kernel, kernel}, {}}, param);

  62.     };

  63. 

  64.     profile(48, 128, 56, 88, 1, 1);

  65.     profile(56, 128, 64, 80, 1, 1);

  66.     profile(24, 3, 256, 320, 3, 2);

  67.     profile(16, 3, 224, 352, 5, 2);

  68.     profile(16, 3, 256, 320, 7, 2);

  69.     profile(8, 8, 56, 88, 3, 1);

  70.     profile(8, 8, 7, 11, 3, 1);

  71.     profile(4, 4, 64, 80, 3, 1);

  72.     profile(108, 108, 7, 7, 3, 1);

  73.     profile(54, 54, 7, 7, 3, 1);

  74.     profile(3, 3, 128, 128, 3, 1);

  75.     profile(3, 3, 112, 112, 3, 1);

  76. }

  77. 

  78. TEST_F(FALLBACK, BENCHMARK_CONVOLUTION_MATRIX_MUL_8832) {

  79.     using Param = Convolution::Param;

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

  81.         Benchmarker<Convolution> benchmarker_float(handle());

  82.         size_t RUN = 50;

  83.         auto tfloat = benchmarker_float.set_display(false)

  84.                               .set_dtype(0, dtype::Int8{})

  85.                               .set_dtype(1, dtype::Int8{})

  86.                               .set_dtype(2, dtype::Int32{})

  87.                               .set_times(RUN)

  88.                               .set_param(param)

  89.                               .exec(shapes);

  90.         size_t IC = shapes[1][1];

  91.         size_t FH = shapes[1][2];

  92.         size_t FW = shapes[1][3];

  93.         TensorLayout dst_layout;

  94.         auto opr = handle()->create_operator<Convolution>();

  95.         opr->param() = param;

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

  97.                            {shapes[1], dtype::Float32()}, dst_layout);

  98.         printf("fp32 flops: %.3f mflops\n",

  99.                (IC * dst_layout.total_nr_elems() * FH * FW * 2) /

  100.                        (tfloat / RUN * 1000));

  101.     };

  102.     auto profile = [&](size_t oc, size_t ic, size_t w, size_t h, size_t kernel,

  103.                        size_t stride) {

  104.         Param param;

  105.         param.stride_h = stride;

  106.         param.stride_w = stride;

  107.         param.pad_h = kernel / 2;

  108.         param.pad_w = kernel / 2;

  109.         param.pad_h = 0;

  110.         param.pad_w = 0;

  111.         printf("oc: %zd ic: %zd w: %zd h: %zd stride: %zd kernel_size: %zd\n",

  112.                oc, ic, w, h, stride, kernel);

  113. 

  114.         run({{1, ic, h, w}, {oc, ic, kernel, kernel}, {}}, param);

  115.     };

  116. 

  117.     profile(48, 128, 56, 88, 1, 1);

  118.     profile(56, 128, 64, 80, 3, 1);

  119.     profile(24, 3, 256, 320, 3, 2);

  120. }

  121. 

  122. TEST_F(FALLBACK, BENCHMARK_CONVOLUTION_MATRIX_MUL_8816) {

  123.     using Param = Convolution::Param;

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

  125.         Benchmarker<Convolution> benchmarker_float(handle());

  126.         size_t RUN = 50;

  127.         auto tfloat = benchmarker_float.set_display(false)

  128.                               .set_dtype(0, dtype::Int8{})

  129.                               .set_dtype(1, dtype::Int8{})

  130.                               .set_dtype(2, dtype::Int16{})

  131.                               .set_times(RUN)

  132.                               .set_param(param)

  133.                               .exec(shapes);

  134.         size_t IC = shapes[1][1];

  135.         size_t FH = shapes[1][2];

  136.         size_t FW = shapes[1][3];

  137.         TensorLayout dst_layout;

  138.         auto opr = handle()->create_operator<Convolution>();

  139.         opr->param() = param;

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

  141.                            {shapes[1], dtype::Float32()}, dst_layout);

  142.         printf("fp32 flops: %.3f mflops\n",

  143.                (IC * dst_layout.total_nr_elems() * FH * FW * 2) /

  144.                        (tfloat / RUN * 1000));

  145.     };

  146.     auto profile = [&](size_t oc, size_t ic, size_t w, size_t h, size_t kernel,

  147.                        size_t stride) {

  148.         Param param;

  149.         param.stride_h = stride;

  150.         param.stride_w = stride;

  151.         param.pad_h = kernel / 2;

  152.         param.pad_w = kernel / 2;

  153.         param.pad_h = 0;

  154.         param.pad_w = 0;

  155.         printf("oc: %zd ic: %zd w: %zd h: %zd stride: %zd kernel_size: %zd\n",

  156.                oc, ic, w, h, stride, kernel);

  157. 

  158.         run({{1, ic, h, w}, {oc, ic, kernel, kernel}, {}}, param);

  159.     };

  160. 

  161.     profile(48, 128, 56, 88, 1, 1);

  162.     profile(48, 128, 56, 88, 1, 2);

  163.     profile(56, 128, 64, 80, 3, 1);

  164.     profile(24, 3, 256, 320, 3, 2);

  165. }

  166. 

  167. TEST_F(FALLBACK, BENCHMARK_CONVOLUTION_BACKWARD_DATA) {

  168.     using Param = ConvolutionBackwardData::Param;

  169.     auto run = [&](const TensorLayoutArray& tensors, Param param) {

  170.         Benchmarker<ConvolutionBackwardData> benchmarker_fallback(handle());

  171.         size_t RUN = 500;

  172.         benchmarker_fallback.set_display(false)

  173.                 .set_dtype(0, dtype::Float32{})

  174.                 .set_dtype(1, dtype::Float32{})

  175.                 .set_times(RUN)

  176.                 .set_param(param);

  177.         auto tmatmul = benchmarker_fallback

  178.                                .set_before_exec_callback(

  179.                                        AlgoChecker<ConvolutionBackwardData>(

  180.                                                "DeconvMatmul"))

  181.                                .exec(tensors);

  182.         auto tdirect = benchmarker_fallback

  183.                                .set_before_exec_callback(

  184.                                        AlgoChecker<ConvolutionBackwardData>(

  185.                                                "DeconvDirect"))

  186.                                .exec(tensors);

  187.         size_t IC = tensors[0][1];

  188.         size_t FH = tensors[0][2];

  189.         size_t FW = tensors[0][3];

  190.         size_t total_flops = IC * tensors[1].total_nr_elems() * FH * FW * 2;

  191.         printf("Direct_time: %.3f ms  Direct_flops: %.3f mflops\n", tdirect,

  192.                total_flops / (tdirect / RUN * 1000));

  193.         printf("Matmul_time: %.3f ms  Matmul_flops: %.3f mflops\n", tmatmul,

  194.                total_flops / (tmatmul / RUN * 1000));

  195.         printf("speedup: %.3f\n", tdirect / tmatmul);

  196.     };

  197. 

  198.     auto profile = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  199.                        size_t fh, size_t fw, size_t stride = 1,

  200.                        size_t padding = 0) {

  201.         Param param;

  202.         param.pad_h = param.pad_w = padding;

  203.         param.stride_h = param.stride_w = stride;

  204.         printf("oc: %zd ic: %zd w: %zd h: %zd stride: %zd kernel_size: %zd\n",

  205.                oc, ic, ow, oh, stride, fh);

  206. 

  207.         TensorLayout diff = TensorLayout{{n, oc, oh, ow}, dtype::Float32()};

  208.         TensorLayout filter = TensorLayout{{oc, ic, fh, fw}, dtype::Float32()};

  209.         TensorLayout grad;

  210.         {

  211.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  212.             opr->param() = param;

  213.             opr->deduce_layout(filter, diff, grad);

  214.         }

  215.         run(TensorLayoutArray{filter, diff, grad}, param);

  216.     };

  217. 

  218.     profile(1, 1, 3, 3, 1, 2, 2);

  219.     profile(1, 2, 3, 3, 2, 2, 2);

  220.     profile(1, 4, 3, 3, 4, 2, 2);

  221.     profile(1, 4, 3, 3, 8, 2, 2);

  222.     profile(1, 8, 3, 3, 4, 2, 2);

  223.     profile(1, 8, 3, 3, 8, 2, 2);

  224. }

  225. 

  226. #endif

  227. 

  228. TEST_F(FALLBACK, CONVOLUTION_MATRIX_MUL) {

  229.     Checker<Convolution> checker(handle());

  230.     using Param = Convolution::Param;

  231. 

  232.     Param param;

  233.     param.sparse = param::Convolution::Sparse::DENSE;

  234.     auto run = [&](size_t n, size_t ic, size_t ih, size_t iw, size_t oc,

  235.                    size_t fh, size_t fw) {

  236.         param.pad_h = param.pad_w = 1;

  237.         param.stride_h = param.stride_w = 1;

  238.         checker.set_param(param);

  239.         checker.execs({{n, ic, ih, iw}, {oc, ic, fh, fw}, {}});

  240.     };

  241. 

  242.     run(1, 3, 128, 128, 5, 3, 3);

  243.     run(1, 56, 128, 64, 80, 1, 1);

  244.     run(1, 8, 8, 7, 11, 3, 1);

  245.     run(1, 54, 54, 7, 7, 3, 1);

  246.     run(1, 3, 3, 128, 128, 3, 1);

  247.     run(1, 3, 3, 112, 112, 3, 1);

  248.     run(1, 1, 1, 1, 1, 3, 3);

  249. }

  250. 

  251. #if MEGDNN_X86

  252. TEST_F(FALLBACK_MULTI_THREADS, CONVOLUTION_8816) {

  253.     Checker<Convolution> checker(handle());

  254.     using Param = Convolution::Param;

  255.     checker.set_before_exec_callback(AlgoChecker<Convolution>(".+FB_GEMV.+"));

  256.     auto run = [&](size_t n, size_t ic, size_t ih, size_t iw, size_t oc,

  257.                    size_t fh, size_t fw, size_t pad, size_t stride,

  258.                    size_t group) {

  259.         Param param;

  260.         param.sparse = group > 1 ? param::Convolution::Sparse::GROUP

  261.                                  : param::Convolution::Sparse::DENSE;

  262.         param.pad_h = param.pad_w = pad;

  263.         param.stride_h = param.stride_w = stride;

  264.         checker.set_param(param);

  265.         if (group > 1) {

  266.             checker.execl(

  267.                     {{{n, ic, ih, iw}, dtype::Int8()},

  268.                      {{group, oc / group, ic / group, fh, fw}, dtype::Int8()},

  269.                      {{}, dtype::Int16()}});

  270.         } else {

  271.             checker.execl({{{n, ic, ih, iw}, dtype::Int8()},

  272.                            {{oc, ic, fh, fw}, dtype::Int8()},

  273.                            {{}, dtype::Int16()}});

  274.         }

  275.     };

  276. 

  277.     for (auto n : {1, 2})

  278.         for (auto ic : {3, 4, 8, 12, 16})

  279.             for (auto oc : {4, 8, 16, 32})

  280.                 for (auto ih : {7, 14, 15, 22})

  281.                     for (auto iw : {7, 13, 11, 32})

  282.                         for (auto filter : {1, 2, 3, 5, 7})

  283.                             for (auto stride : {1, 2})

  284.                                 for (auto pad : {0, filter / 2}) {

  285.                                     run(n, ic, ih, iw, oc, filter, filter, pad,

  286.                                         stride, 1);

  287.                                     if (ic == oc) {

  288.                                         run(n, ic, ih, iw, oc, filter, filter,

  289.                                             pad, stride, ic);

  290.                                     }

  291.                                 }

  292. }

  293. #endif

  294. 

  295. TEST_F(FALLBACK, CONVOLUTION_NAIVE_ALGO_FP16) {

  296.     Checker<Convolution> checker(handle());

  297.     using Param = Convolution::Param;

  298.     checker.set_before_exec_callback(

  299.             AlgoChecker<ConvolutionForward>("NAIVE_ALGO"));

  300.     Param param;

  301.     param.sparse = param::Convolution::Sparse::DENSE;

  302.     auto run = [&](size_t n, size_t ic, size_t ih, size_t iw, size_t oc,

  303.                    size_t fh, size_t fw) {

  304.         param.pad_h = param.pad_w = 1;

  305.         param.stride_h = param.stride_w = 1;

  306.         for (auto cmode :

  307.              std::vector<Param::ComputeMode>{Param::ComputeMode::DEFAULT,

  308.                                              Param::ComputeMode::FLOAT32}) {

  309.             param.compute_mode = cmode;

  310.             checker.set_param(param)

  311.                     .set_dtype(0, dtype::Float16())

  312.                     .set_dtype(1, dtype::Float16())

  313.                     // Use inferred output dtype.

  314.                     .set_dtype(2, {});

  315.             checker.execs({{n, ic, ih, iw}, {oc, ic, fh, fw}, {}});

  316.         }

  317.     };

  318. 

  319.     run(1, 3, 128, 128, 5, 3, 3);

  320.     run(1, 8, 8, 7, 11, 3, 1);

  321. }

  322. 

  323. TEST_F(FALLBACK_MULTI_THREADS, CONVOLUTION_NAIVE_FALLBACK) {

  324.     Checker<Convolution> checker(handle());

  325.     using Param = Convolution::Param;

  326.     checker.set_before_exec_callback(

  327.             AlgoChecker<ConvolutionForward>("FALLBACK_ALGO"));

  328.     Param param;

  329.     auto run = [&](size_t n, size_t group, size_t ic, size_t ih, size_t iw,

  330.                    size_t oc, size_t fh, size_t fw) {

  331.         param.sparse = param::Convolution::Sparse::GROUP;

  332.         param.pad_h = param.pad_w = 1;

  333.         param.stride_h = param.stride_w = 1;

  334.         TensorShape src{n, ic, ih, iw},

  335.                 filter{group, oc / group, ic / group, fh, fw};

  336.         checker.set_param(param)

  337.                 .set_dtype(0, dtype::Float32())

  338.                 .set_dtype(1, dtype::Float32())

  339.                 .set_dtype(2, {});

  340.         checker.execs({src, filter, {}});

  341.     };

  342.     run(4, 1, 3, 21, 15, 5, 3, 3);

  343.     run(1, 8, 56, 24, 31, 56, 1, 1);

  344.     run(4, 8, 8, 8, 7, 8, 3, 1);

  345.     run(8, 1, 54, 54, 7, 7, 3, 1);

  346.     run(100, 1, 1, 1, 1, 1, 3, 3);

  347. }

  348. 

  349. TEST_F(FALLBACK_MULTI_THREADS, CONVOLUTION_NAIVE_ALGO) {

  350.     Checker<Convolution> checker(handle());

  351.     using Param = Convolution::Param;

  352.     checker.set_before_exec_callback(

  353.             AlgoChecker<ConvolutionForward>("NAIVE_ALGO"));

  354.     Param param;

  355.     auto run = [&](size_t n, size_t group, size_t ic, size_t ih, size_t iw,

  356.                    size_t oc, size_t fh, size_t fw) {

  357.         param.sparse = param::Convolution::Sparse::GROUP;

  358.         param.pad_h = param.pad_w = 1;

  359.         param.stride_h = param.stride_w = 1;

  360.         TensorShape src{n, ic, ih, iw},

  361.                 filter{group, oc / group, ic / group, fh, fw};

  362.         checker.set_param(param).set_dtype(2, {});

  363.         //! float32

  364.         checker.set_dtype(0, dtype::Float32()).set_dtype(1, dtype::Float32());

  365.         checker.execs({src, filter, {}});

  366.         //! float16

  367.         checker.set_dtype(0, dtype::Float16()).set_dtype(1, dtype::Float16());

  368.         checker.execs({src, filter, {}});

  369.         //! Qint8

  370.         checker.set_dtype(0, dtype::QuantizedS8(3.34f))

  371.                 .set_dtype(1, dtype::QuantizedS8(0.32f));

  372.         checker.execs({src, filter, {}});

  373.         //! Quint8

  374.         checker.set_dtype(0, dtype::Quantized8Asymm(3.34f,

  375.                                                     static_cast<uint8_t>(21)))

  376.                 .set_dtype(1, dtype::Quantized8Asymm(0.32f,

  377.                                                      static_cast<uint8_t>(15)));

  378.         checker.execs({src, filter, {}});

  379.     };

  380.     run(4, 1, 3, 21, 15, 5, 3, 3);

  381.     run(1, 8, 56, 24, 31, 56, 1, 1);

  382.     run(4, 8, 8, 8, 7, 8, 3, 1);

  383.     run(8, 1, 54, 54, 7, 7, 3, 1);

  384.     run(100, 1, 1, 1, 1, 1, 3, 3);

  385. }

  386. 

  387. TEST_F(FALLBACK, CONVOLUTION_MATRIX_MUL_SINT8) {

  388.     Checker<Convolution> checker(handle());

  389.     using Param = Convolution::Param;

  390. 

  391.     Param param;

  392.     param.sparse = param::Convolution::Sparse::DENSE;

  393.     auto run = [&](size_t n, size_t ic, size_t ih, size_t iw, size_t oc,

  394.                    size_t fh, size_t fw) {

  395.         param.pad_h = param.pad_w = 1;

  396.         param.stride_h = param.stride_w = 1;

  397.         checker.set_param(param)

  398.                 .set_dtype(0, dtype::QuantizedS8(0.2f))

  399.                 .set_dtype(1, dtype::QuantizedS8(0.2f))

  400.                 // Use inferred output dtype.

  401.                 .set_dtype(2, {});

  402.         checker.execs({{n, ic, ih, iw}, {oc, ic, fh, fw}, {}});

  403.     };

  404. 

  405.     run(1, 3, 128, 128, 5, 3, 3);

  406.     run(1, 56, 128, 64, 80, 1, 1);

  407.     run(1, 8, 8, 7, 11, 3, 1);

  408.     run(1, 54, 54, 7, 7, 3, 1);

  409.     run(1, 3, 3, 128, 128, 3, 1);

  410.     run(1, 3, 3, 112, 112, 3, 1);

  411.     run(1, 1, 1, 1, 1, 3, 3);

  412. }

  413. 

  414. TEST_F(FALLBACK, CONVOLUTION_BACKWARD_DATA) {

  415.     Checker<ConvolutionBackwardData> checker(handle());

  416.     using Param = ConvolutionBackwardData::Param;

  417. 

  418.     Param param;

  419.     auto run = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  420.                    size_t fh, size_t fw, size_t stride, size_t padding,

  421.                    size_t dilate = 1, size_t group = 1) {

  422.         param.pad_h = param.pad_w = padding;

  423.         param.stride_h = param.stride_w = stride;

  424.         param.dilate_h = param.dilate_w = dilate;

  425. 

  426.         TensorLayout diff =

  427.                 TensorLayout{{n, oc * group, oh, ow}, dtype::Float32()};

  428.         TensorLayout grad;

  429.         TensorLayout filter;

  430.         if (group == 1) {

  431.             param.sparse = Param::Sparse::DENSE;

  432.             filter = {{oc, ic, fh, fw}, dtype::Float32()};

  433.         } else {

  434.             param.sparse = Param::Sparse::GROUP;

  435.             filter = {{group, oc, ic, fh, fw}, dtype::Float32()};

  436.         }

  437.         // TensorLayout grad;

  438.         {

  439.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  440.             opr->param() = param;

  441.             opr->deduce_layout(filter, diff, grad);

  442.         }

  443.         checker.set_param(param)

  444.                 .set_dtype(0, dtype::Float32())

  445.                 .set_dtype(1, dtype::Float32());

  446.         checker.exec(TensorLayoutArray{filter, diff, grad});

  447.     };

  448. 

  449.     for (auto mode :

  450.          {Param::Mode::CONVOLUTION, Param::Mode::CROSS_CORRELATION}) {

  451.         param.mode = mode;

  452.         run(4, 3, 10, 13, 5, 1, 1, 1, 0, 1, 1);

  453.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 1, 2);

  454.         run(4, 3, 10, 45, 2, 1, 1, 1, 0, 4, 3);

  455.         run(2, 3, 9, 12, 2, 4, 6, 1, 0, 1, 2);

  456.         run(3, 4, 17, 32, 2, 3, 2, 5, 4, 4, 3);

  457.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 2, 2);

  458.         run(2, 3, 20, 33, 3, 5, 7, 4, 15, 2, 3);

  459.         run(4, 4, 6, 7, 9, 3, 2, 2, 1, 3, 2);

  460.     }

  461. }

  462. 

  463. TEST_F(FALLBACK, CONVOLUTION_BACKWARD_DATA_INT8_INT8_INT32) {

  464.     Checker<ConvolutionBackwardData> checker(handle());

  465.     using Param = ConvolutionBackwardData::Param;

  466.     Param param;

  467. 

  468.     auto run = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  469.                    size_t fh, size_t fw, size_t stride, size_t padding,

  470.                    size_t dilate = 1, size_t group = 1) {

  471.         param.pad_h = param.pad_w = padding;

  472.         param.stride_h = param.stride_w = stride;

  473.         param.dilate_h = param.dilate_w = dilate;

  474. 

  475.         TensorLayout diff =

  476.                 TensorLayout{{n, oc * group, oh, ow}, dtype::Int8()};

  477.         TensorLayout grad;

  478.         TensorLayout filter;

  479.         if (group == 1) {

  480.             param.sparse = Param::Sparse::DENSE;

  481.             filter = {{oc, ic, fh, fw}, dtype::Int8()};

  482.         } else {

  483.             param.sparse = Param::Sparse::GROUP;

  484.             filter = {{group, oc, ic, fh, fw}, dtype::Int8()};

  485.         }

  486.         // TensorLayout grad;

  487.         {

  488.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  489.             opr->param() = param;

  490.             opr->deduce_layout(filter, diff, grad);

  491.         }

  492.         checker.set_param(param)

  493.                 .set_dtype(0, dtype::Int8())

  494.                 .set_dtype(1, dtype::Int8())

  495.                 .set_dtype(2, dtype::Int32());

  496.         checker.exec(TensorLayoutArray{filter, diff, grad});

  497.     };

  498. 

  499.     for (auto mode :

  500.          {Param::Mode::CONVOLUTION, Param::Mode::CROSS_CORRELATION}) {

  501.         param.mode = mode;

  502.         run(4, 3, 10, 13, 5, 1, 1, 1, 0, 1, 1);

  503.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 1, 2);

  504.         run(4, 3, 10, 45, 2, 1, 1, 1, 0, 4, 3);

  505.         run(2, 3, 9, 12, 2, 4, 6, 1, 0, 1, 2);

  506.         run(3, 4, 17, 32, 2, 3, 2, 5, 4, 4, 3);

  507.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 2, 2);

  508.         run(2, 3, 20, 33, 3, 5, 7, 4, 15, 2, 3);

  509.         run(4, 4, 6, 7, 9, 3, 2, 2, 1, 3, 2);

  510.     }

  511. }

  512. 

  513. TEST_F(FALLBACK, CONVOLUTION_BACKWARD_DATA_SINT8) {

  514.     Checker<ConvolutionBackwardData> checker(handle());

  515.     using Param = ConvolutionBackwardData::Param;

  516.     Param param;

  517. 

  518.     auto run = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  519.                    size_t fh, size_t fw, size_t stride, size_t padding,

  520.                    size_t dilate = 1, size_t group = 1) {

  521.         param.pad_h = param.pad_w = padding;

  522.         param.stride_h = param.stride_w = stride;

  523.         param.dilate_h = param.dilate_w = dilate;

  524. 

  525.         TensorLayout diff =

  526.                 TensorLayout{{n, oc * group, oh, ow}, dtype::QuantizedS8(0.2f)};

  527.         TensorLayout grad;

  528.         TensorLayout filter;

  529.         if (group == 1) {

  530.             param.sparse = Param::Sparse::DENSE;

  531.             filter = {{oc, ic, fh, fw}, dtype::QuantizedS8(0.2f)};

  532.         } else {

  533.             param.sparse = Param::Sparse::GROUP;

  534.             filter = {{group, oc, ic, fh, fw}, dtype::QuantizedS8(0.2f)};

  535.         }

  536.         // TensorLayout grad;

  537.         {

  538.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  539.             opr->param() = param;

  540.             opr->deduce_layout(filter, diff, grad);

  541.         }

  542.         checker.set_param(param)

  543.                 .set_dtype(0, dtype::QuantizedS8(0.2f))

  544.                 .set_dtype(1, dtype::QuantizedS8(0.2f))

  545.                 .set_dtype(2, {});

  546.         checker.exec(TensorLayoutArray{filter, diff, grad});

  547.     };

  548. 

  549.     for (auto mode :

  550.          {Param::Mode::CONVOLUTION, Param::Mode::CROSS_CORRELATION}) {

  551.         param.mode = mode;

  552.         run(4, 3, 10, 13, 5, 1, 1, 1, 0, 1, 1);

  553.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 1, 2);

  554.         run(4, 3, 10, 45, 2, 1, 1, 1, 0, 4, 3);

  555.         run(2, 3, 9, 12, 2, 4, 6, 1, 0, 1, 2);

  556.         run(3, 4, 17, 32, 2, 3, 2, 5, 4, 4, 3);

  557.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 2, 2);

  558.         run(2, 3, 20, 33, 3, 5, 7, 4, 15, 2, 3);

  559.         run(4, 4, 6, 7, 9, 3, 2, 2, 1, 3, 2);

  560.     }

  561. }

  562. 

  563. TEST_F(FALLBACK, CONVOLUTION_BACKWARD_DATA_QUINT8) {

  564.     Checker<ConvolutionBackwardData> checker(handle());

  565.     using Param = ConvolutionBackwardData::Param;

  566.     Param param;

  567. 

  568.     auto run = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  569.                    size_t fh, size_t fw, size_t stride, size_t padding,

  570.                    size_t dilate = 1, size_t group = 1) {

  571.         param.pad_h = param.pad_w = padding;

  572.         param.stride_h = param.stride_w = stride;

  573.         param.dilate_h = param.dilate_w = dilate;

  574. 

  575.         TensorLayout diff =

  576.                 TensorLayout{{n, oc * group, oh, ow},

  577.                              dtype::Quantized8Asymm(1.3f, (uint8_t)129)};

  578.         TensorLayout grad;

  579.         TensorLayout filter;

  580.         if (group == 1) {

  581.             param.sparse = Param::Sparse::DENSE;

  582.             filter = {{oc, ic, fh, fw},

  583.                       dtype::Quantized8Asymm(1.2f, (uint8_t)127)};

  584.         } else {

  585.             param.sparse = Param::Sparse::GROUP;

  586.             filter = {{group, oc, ic, fh, fw},

  587.                       dtype::Quantized8Asymm(1.2f, (uint8_t)127)};

  588.         }

  589.         // TensorLayout grad;

  590.         {

  591.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  592.             opr->param() = param;

  593.             opr->deduce_layout(filter, diff, grad);

  594.         }

  595.         NormalRNG rng(128.f);

  596.         checker.set_param(param)

  597.                 .set_dtype(0, dtype::Quantized8Asymm(1.2f, (uint8_t)127))

  598.                 .set_dtype(1, dtype::Quantized8Asymm(1.3f, (uint8_t)129))

  599.                 .set_dtype(2, {});

  600.         checker.set_rng(0, &rng).set_rng(1, &rng);

  601.         checker.exec(TensorLayoutArray{filter, diff, grad});

  602.     };

  603. 

  604.     for (auto mode :

  605.          {Param::Mode::CONVOLUTION, Param::Mode::CROSS_CORRELATION}) {

  606.         param.mode = mode;

  607.         run(4, 3, 10, 13, 5, 1, 1, 1, 0, 1, 1);

  608.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 1, 2);

  609.         run(4, 3, 10, 45, 2, 1, 1, 1, 0, 4, 3);

  610.         run(2, 3, 9, 12, 2, 4, 6, 1, 0, 1, 2);

  611.         run(3, 4, 17, 32, 2, 3, 2, 5, 4, 4, 3);

  612.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 2, 2);

  613.         run(2, 3, 20, 33, 3, 5, 7, 4, 15, 2, 3);

  614.         run(4, 4, 6, 7, 9, 3, 2, 2, 1, 3, 2);

  615.     }

  616. }

  617. 

  618. TEST_F(FALLBACK, CONVOLUTION_BACKWARD_DATA_NAIVE_ALGO) {

  619.     Checker<ConvolutionBackwardData> checker(handle());

  620.     checker.set_before_exec_callback(

  621.             AlgoChecker<ConvolutionBackwardData>("DeconvNaive"));

  622.     using Param = ConvolutionBackwardData::Param;

  623.     Param param;

  624. 

  625.     auto run = [&](size_t n, size_t ic, size_t oh, size_t ow, size_t oc,

  626.                    size_t fh, size_t fw, size_t stride, size_t padding,

  627.                    size_t dilate = 1, size_t group = 1) {

  628.         param.pad_h = param.pad_w = padding;

  629.         param.stride_h = param.stride_w = stride;

  630.         param.dilate_h = param.dilate_w = dilate;

  631. 

  632.         TensorLayout diff =

  633.                 TensorLayout{{n, oc * group, oh, ow}, dtype::Float32()};

  634.         TensorLayout grad;

  635.         TensorLayout filter;

  636.         if (group == 1) {

  637.             param.sparse = Param::Sparse::DENSE;

  638.             filter = {{oc, ic, fh, fw}, dtype::Float32()};

  639.         } else {

  640.             param.sparse = Param::Sparse::GROUP;

  641.             filter = {{group, oc, ic, fh, fw}, dtype::Float32()};

  642.         }

  643.         // TensorLayout grad;

  644.         {

  645.             auto opr = handle()->create_operator<ConvolutionBackwardData>();

  646.             opr->param() = param;

  647.             opr->deduce_layout(filter, diff, grad);

  648.         }

  649.         checker.set_param(param);

  650.         checker.exec(TensorLayoutArray{filter, diff, grad});

  651.     };

  652. 

  653.     for (auto mode :

  654.          {Param::Mode::CONVOLUTION, Param::Mode::CROSS_CORRELATION}) {

  655.         param.mode = mode;

  656.         run(4, 3, 10, 13, 5, 1, 1, 1, 0, 1, 1);

  657.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 1, 2);

  658.         run(4, 3, 10, 45, 2, 1, 1, 1, 0, 4, 3);

  659.         run(2, 3, 9, 12, 2, 4, 6, 1, 0, 1, 2);

  660.         run(3, 4, 17, 32, 2, 3, 2, 5, 4, 4, 3);

  661.         run(5, 5, 24, 43, 11, 9, 3, 3, 12, 2, 2);

  662.         run(2, 3, 20, 33, 3, 5, 7, 4, 15, 2, 3);

  663.         run(4, 4, 6, 7, 9, 3, 2, 2, 1, 3, 2);

  664.     }

  665. }

  666. 

  667. // vim: syntax=cpp.doxygen