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: 4fe68ac9ed
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4fe68ac9ed'
${ noResults }
MegEngine/dnn/test/cuda/relayout_format.cpp

444 lines
17 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/cuda/relayout_format.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 "megdnn/dtype.h"

  13. #include "megdnn/oprs.h"

  14. #include "test/cuda/benchmark.h"

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

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

  17. #include "test/cuda/fixture.h"

  18. 

  19. using namespace megdnn;

  20. using namespace test;

  21. 

  22. TEST_F(CUDA, RELAYOUT_FORMAT) {

  23.     Checker<RelayoutFormat> checker(handle_cuda());

  24.     UniformIntRNG rng{-50, 50};

  25.     param::RelayoutFormat param;

  26.     param.mode = param::RelayoutFormat::Mode::NCHW4_CHWN4;

  27. 

  28.     checker.set_dtype(0, dtype::QuantizedS8{0.1f})

  29.             .set_dtype(1, dtype::QuantizedS8{0.1f})

  30.             .set_rng(0, &rng)

  31.             .set_param(param)

  32.             .execs({{22, 23, 24, 25, 4}, {}});

  33.     param.mode = param::RelayoutFormat::Mode::CHWN4_NCHW4;

  34.     checker.execs({{22, 23, 24, 25, 4}, {}});

  35. }

  36. 

  37. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW4_NCHW) {

  38.     Checker<RelayoutFormat> checker(handle_cuda());

  39.     UniformIntRNG rng{-50, 50};

  40.     param::RelayoutFormat param;

  41.     param.mode = param::RelayoutFormat::Mode::NCHW4_NCHW;

  42. 

  43.     checker.set_dtype(0, dtype::QuantizedS8{0.1f})

  44.             .set_dtype(1, dtype::QuantizedS8{0.1f})

  45.             .set_rng(0, &rng)

  46.             .set_param(param)

  47.             .execs({{1, 1, 2, 2, 4}, {}});

  48. 

  49.     checker.set_dtype(0, dtype::QuantizedS8{0.1f})

  50.             .set_dtype(1, dtype::QuantizedS8{0.1f})

  51.             .set_rng(0, &rng)

  52.             .set_param(param)

  53.             .execs({{22, 23, 24, 25, 4}, {}});

  54. 

  55.     param.oc = 90;

  56.     checker.set_dtype(0, dtype::QuantizedS8{0.1f})

  57.             .set_dtype(1, dtype::QuantizedS8{0.1f})

  58.             .set_rng(0, &rng)

  59.             .set_param(param)

  60.             .execs({{22, 23, 24, 25, 4}, {}});

  61. 

  62.     param.oc = 16;

  63.     param.group = 8;

  64.     checker.set_dtype(0, dtype::QuantizedS8{0.1f})

  65.             .set_dtype(1, dtype::QuantizedS8{0.1f})

  66.             .set_rng(0, &rng)

  67.             .set_param(param)

  68.             .execs({{11, 16, 22, 33, 4}, {}});

  69. }

  70. 

  71. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW4) {

  72.     Checker<RelayoutFormat> checker(handle_cuda());

  73.     UniformIntRNG rng{-50, 50};

  74.     param::RelayoutFormat param;

  75.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4;

  76. 

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

  78.         for (size_t c : {1, 2, 3, 4, 8, 9, 11, 16}) {

  79.             for (size_t h : {3, 7, 12, 16, 22, 59, 83}) {

  80.                 for (size_t w : {3, 22, 63, 128, 256}) {

  81.                     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  82.                             .set_dtype(1, dtype::QuantizedS8{1.f})

  83.                             .set_rng(0, &rng)

  84.                             .set_param(param)

  85.                             .execs({{n, c, h, w}, {}});

  86. 

  87.                     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  88.                             .set_dtype(1, dtype::QuantizedS8{2.f})

  89.                             .set_rng(0, &rng)

  90.                             .set_param(param)

  91.                             .execs({{n, c, h, w}, {}});

  92. 

  93.                     checker.set_dtype(0, dtype::QuantizedS32{1.f})

  94.                             .set_dtype(1, dtype::QuantizedS32{1.f})

  95.                             .set_rng(0, &rng)

  96.                             .set_param(param)

  97.                             .execs({{n, c, h, w}, {}});

  98.                 }

  99.             }

  100.         }

  101.     }

  102. 

  103.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  104.             .set_dtype(1, dtype::QuantizedS8{1.f})

  105.             .set_rng(0, &rng)

  106.             .set_param(param)

  107.             .execs({{8, 3, 224, 224}, {}});

  108. 

  109.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  110.             .set_dtype(1, dtype::QuantizedS8{1.f})

  111.             .set_rng(0, &rng)

  112.             .set_param(param)

  113.             .execs({{8, 3, 600, 600}, {}});

  114. 

  115.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  116.             .set_dtype(1, dtype::QuantizedS8{1.f})

  117.             .set_rng(0, &rng)

  118.             .set_param(param)

  119.             .execs({{1, 6, 768, 1280}, {}});

  120. 

  121.     param.group = 2;

  122.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  123.             .set_dtype(1, dtype::QuantizedS8{1.f})

  124.             .set_rng(0, &rng)

  125.             .set_param(param)

  126.             .execs({{8, 6, 300, 300}, {}});

  127. 

  128.     param.group = 3;

  129.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  130.             .set_dtype(1, dtype::QuantizedS8{1.f})

  131.             .set_rng(0, &rng)

  132.             .set_param(param)

  133.             .execs({{8, 6, 300, 300}, {}});

  134. }

  135. 

  136. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW4_WEIGHT) {

  137.     Checker<RelayoutFormat> checker(handle_cuda());

  138.     UniformIntRNG rng{-50, 50};

  139.     param::RelayoutFormat param;

  140.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4_WEIGHT;

  141. 

  142.     for (size_t oc : {1, 3, 4, 16, 33}) {

  143.         for (size_t ic : {1, 2, 3, 4, 8, 9, 11, 16, 33}) {

  144.             for (size_t h : {3, 5, 7}) {

  145.                 for (size_t w : {3, 5, 7}) {

  146.                     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  147.                             .set_dtype(1, dtype::QuantizedS8{1.f})

  148.                             .set_rng(0, &rng)

  149.                             .set_param(param)

  150.                             .execs({{oc, ic, h, w}, {}});

  151.                 }

  152.             }

  153.         }

  154.     }

  155. 

  156.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  157.             .set_dtype(1, dtype::QuantizedS8{1.f})

  158.             .set_rng(0, &rng)

  159.             .set_param(param)

  160.             .execs({{13, 13, 5, 5}, {}});

  161. 

  162.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  163.             .set_dtype(1, dtype::QuantizedS8{1.f})

  164.             .set_rng(0, &rng)

  165.             .set_param(param)

  166.             .execs({{4, 16, 16, 3, 3}, {}});

  167. 

  168.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  169.             .set_dtype(1, dtype::QuantizedS8{1.f})

  170.             .set_rng(0, &rng)

  171.             .set_param(param)

  172.             .execs({{4, 13, 11, 3, 3}, {}});

  173. }

  174. 

  175. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW4_DEFAULT) {

  176.     Checker<RelayoutFormat> checker(handle_cuda());

  177.     UniformIntRNG rng{0, 50};

  178.     param::RelayoutFormat param;

  179.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4;

  180.     for (size_t n : {1, 3}) {

  181.         for (size_t c : {1, 2, 3, 4, 8, 9, 11, 16}) {

  182.             for (size_t h : {3, 7, 12, 16, 59, 83}) {

  183.                 for (size_t w : {3, 63, 128, 256}) {

  184.                     checker.set_dtype(0, dtype::Quantized8Asymm{1.f, 128})

  185.                             .set_dtype(1, dtype::QuantizedS8{1.f})

  186.                             .set_rng(0, &rng)

  187.                             .set_param(param)

  188.                             .execs({{n, c, h, w}, {}});

  189.                 }

  190.             }

  191.         }

  192.     }

  193. }

  194. 

  195. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW4_U8) {

  196.     Checker<RelayoutFormat> checker(handle_cuda());

  197.     UniformIntRNG rng{0, 255};

  198.     param::RelayoutFormat param;

  199.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4;

  200.     for (size_t n : {1, 3}) {

  201.         for (size_t c : {1, 2, 3, 4, 8, 9, 11, 16}) {

  202.             for (size_t h : {3, 7, 12, 16, 59, 83}) {

  203.                 for (size_t w : {3, 13, 3 * 4, 63 * 4, 128 * 4, 256 * 4}) {

  204.                     checker.set_dtype(0, dtype::Uint8())

  205.                             .set_dtype(1, dtype::QuantizedS8{1.f})

  206.                             .set_rng(0, &rng)

  207.                             .set_param(param)

  208.                             .execs({{n, c, h, w}, {}});

  209. 

  210.                     checker.set_dtype(0, dtype::Quantized8Asymm{1.f, 128})

  211.                             .set_dtype(1, dtype::QuantizedS8{1.f})

  212.                             .set_rng(0, &rng)

  213.                             .set_param(param)

  214.                             .execs({{n, c, h, w}, {}});

  215. 

  216.                     checker.set_dtype(0, dtype::Uint8())

  217.                             .set_dtype(1, dtype::QuantizedS8{2.5f})

  218.                             .set_rng(0, &rng)

  219.                             .set_param(param)

  220.                             .execs({{n, c, h, w}, {}});

  221.                 }

  222.             }

  223.         }

  224.     }

  225. }

  226. 

  227. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW4_IC_SMALL) {

  228.     Checker<RelayoutFormat> checker(handle_cuda());

  229.     UniformIntRNG rng{0, 50};

  230.     param::RelayoutFormat param;

  231.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4_IC_SMALL;

  232. 

  233.     checker.set_dtype(0, dtype::QuantizedS8{1.f})

  234.             .set_dtype(1, dtype::QuantizedS8{1.f})

  235.             .set_rng(0, &rng)

  236.             .set_param(param)

  237.             .execs({{8, 3, 768, 1280}, {}});

  238. }

  239. 

  240. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW_NCHW64) {

  241.     Checker<RelayoutFormat> checker(handle_cuda());

  242.     UniformIntRNG s4{-8, 7};

  243.     UniformIntRNG u4{0, 15};

  244.     param::RelayoutFormat param;

  245.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW64;

  246.     for (size_t n : {1, 3}) {

  247.         for (size_t c : {15, 64, 128}) {

  248.             for (size_t h : {7, 14, 16, 28}) {

  249.                 for (size_t w : {2, 3, 7, 8, 16, 31}) {

  250.                     checker.set_dtype(0, dtype::QuantizedS4{2.f})

  251.                             .set_dtype(1, dtype::QuantizedS4{2.f})

  252.                             .set_rng(0, &s4)

  253.                             .set_param(param)

  254.                             .execs({{n, c, h, w}, {}});

  255. 

  256.                     checker.set_dtype(0, dtype::Quantized4Asymm{1.2f, 8})

  257.                             .set_dtype(1, dtype::Quantized4Asymm{1.2f, 4})

  258.                             .set_rng(0, &u4)

  259.                             .set_param(param)

  260.                             .execs({{n, c, h, w}, {}});

  261.  

  262.                     checker.set_dtype(0, dtype::QuantizedS4{1.19990307f})

  263.                             .set_dtype(1, dtype::QuantizedS4{1.f})

  264.                             .set_rng(0, &s4)

  265.                             .set_param(param)

  266.                             .execs({{n, c, h, w}, {}});

  267.                

  268.                     checker.set_dtype(0, dtype::Quantized4Asymm{1.19990307f, 8})

  269.                             .set_dtype(1, dtype::Quantized4Asymm{1.f, 4})

  270.                             .set_rng(0, &u4)

  271.                             .set_param(param)

  272.                             .set_epsilon(1e-3)

  273.                             .execs({{n, c, h, w}, {}});

  274.                 }

  275.             }

  276.         }

  277.     }

  278. }

  279. 

  280. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW64_NCHW) {

  281.     Checker<RelayoutFormat> checker(handle_cuda());

  282.     UniformIntRNG s4{-8, 7};

  283.     UniformIntRNG u4{0, 15};

  284.     param::RelayoutFormat param;

  285.     param.mode = param::RelayoutFormat::Mode::NCHW64_NCHW;

  286.     for (size_t n : {1, 3}) {

  287.         for (size_t c : {15, 64, 128}) {

  288.             for (size_t h : {7, 14, 16, 28}) {

  289.                 for (size_t w : {2, 3, 4, 7, 14, 16, 17}) {

  290.                     if (c % 64 != 0) {

  291.                         param.oc = c;

  292.                     } else {

  293.                         param.oc = 0;

  294.                     }

  295.                     checker.set_dtype(0, dtype::QuantizedS4{2.f})

  296.                             .set_dtype(1, dtype::QuantizedS4{2.f})

  297.                             .set_rng(0, &s4)

  298.                             .set_param(param)

  299.                             .set_epsilon(1e-3)

  300.                             .execs({{n, (c + 63) / 64, h, w, 64}, {}});

  301. 

  302.                     checker.set_dtype(0, dtype::Quantized4Asymm{1.2f, 4})

  303.                             .set_dtype(1, dtype::Quantized4Asymm{1.2f, 8})

  304.                             .set_rng(0, &u4)

  305.                             .set_param(param)

  306.                             .set_epsilon(1e-3)

  307.                             .execs({{n, (c + 63) / 64, h, w, 64}, {}});

  308. 

  309.                     checker.set_dtype(0, dtype::QuantizedS4{1.19990307f})

  310.                             .set_dtype(1, dtype::QuantizedS4{1.f})

  311.                             .set_rng(0, &s4)

  312.                             .set_param(param)

  313.                             .set_epsilon(1e-3)

  314.                             .execs({{n, (c + 63) / 64, h, w, 64}, {}});

  315. 

  316.                     checker.set_dtype(0, dtype::Quantized4Asymm{1.20211209f, 8})

  317.                             .set_dtype(1, dtype::Quantized4Asymm{1.f, 4})

  318.                             .set_rng(0, &u4)

  319.                             .set_param(param)

  320.                             .set_epsilon(1e-3)

  321.                             .execs({{n, (c + 63) / 64, h, w, 64}, {}});

  322.                 }

  323.             }

  324.         }

  325.     }

  326. }

  327. 

  328. #if MEGDNN_WITH_BENCHMARK

  329. TEST_F(CUDA, BENCHMARK_RELAYOUT_FORMAT) {

  330.     using Param = RelayoutFormat::Param;

  331. 

  332.     auto run = [&](const TensorShapeArray& shapes, Param param,

  333.                    Param default_param) {

  334.         Benchmarker<RelayoutFormat> benchmarker(handle_cuda());

  335.         benchmarker.set_param(param);

  336.         benchmarker.set_dtype(0, dtype::QuantizedS8{1.f})

  337.                 .set_dtype(1, dtype::QuantizedS8{1.f});

  338. 

  339.         Benchmarker<RelayoutFormat> benchmarker_default(handle_cuda());

  340.         benchmarker_default.set_param(default_param);

  341.         benchmarker_default.set_dtype(0, dtype::QuantizedS8{1.f})

  342.                 .set_dtype(1, dtype::QuantizedS8{1.f});

  343.         for (auto&& shape : shapes) {

  344.             double memaccess = (double(shape.total_nr_elems()) +

  345.                                 double(shape[0]) * ((shape[1] + 3) / 4 * 4) *

  346.                                         shape[2] * shape[3]) *

  347.                                1e-6;

  348.             auto time_ms = benchmarker.execs({shape, {}});

  349.             if (shape[1] <= 4) {

  350.                 auto time_default_ms = benchmarker_default.execs({shape, {}});

  351.                 printf("execute %s, time %.4f ms, %.4f GB/s, default %.4f "

  352.                        "GB/s\n",

  353.                        shape.to_string().c_str(), time_ms, memaccess / time_ms,

  354.                        memaccess / time_default_ms);

  355.             } else {

  356.                 printf("execute %s, time %.4f ms, %.4f GB/s\n",

  357.                        shape.to_string().c_str(), time_ms, memaccess / time_ms);

  358.             }

  359.         }

  360.     };

  361. 

  362.     TensorShapeArray shapes = {

  363.             {8, 1, 768, 1280}, {8, 3, 768, 1280},  {8, 3, 224, 224},

  364.             {8, 4, 768, 1280}, {64, 3, 768, 1280},

  365.     };

  366.     {

  367.         Param param;

  368.         param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4;

  369.         Param default_param;

  370.         default_param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4_IC_SMALL;

  371.         run(shapes, param, default_param);

  372.     }

  373. }

  374. 

  375. TEST_F(CUDA, BENCHMARK_RELAYOUT_FORMAT_QS4) {

  376.     using Param = RelayoutFormat::Param;

  377. 

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

  379.         CUBenchmarker<RelayoutFormat> benchmarker(handle_cuda());

  380.         benchmarker.set_param(param);

  381.         benchmarker.set_dtype(0, dtype::QuantizedS4{1.19990307f})

  382.                 .set_dtype(1, dtype::QuantizedS4{1.19990307f});

  383. 

  384.         for (auto&& shape : shapes) {

  385.             double memaccess =

  386.                     double(TensorLayout(shape, dtype::QuantizedS4{1.f})

  387.                                    .span()

  388.                                    .dist_byte()) *

  389.                     2e-6;

  390.             auto time_ms = benchmarker.execs({shape, {}});

  391.             printf("execute %s, time %.4f ms, %.4f GB/s\n",

  392.                    shape.to_string().c_str(), time_ms, memaccess / time_ms);

  393.         }

  394.     };

  395. 

  396.     {

  397.         TensorShapeArray shapes = {

  398.                 {1, 64, 56, 56},   {16, 64, 56, 56}, {64, 64, 56, 56},

  399.                 {1, 64, 56, 55},   {16, 64, 56, 55}, {64, 64, 56, 55},

  400.                 {1, 256, 384, 640},

  401.         };

  402.         Param param;

  403.         param.mode = param::RelayoutFormat::Mode::NCHW_NCHW64;

  404.         run(shapes, param);

  405.     }

  406.     {

  407.         TensorShapeArray shapes = {

  408.                 {64, 1, 56, 56, 64},

  409.                 {1, 32, 7, 7, 64},

  410.                 {16, 32, 7, 7, 64},

  411.                 {64, 32, 7, 7, 64}, 

  412.                 {1, 4, 384, 640, 64}, 

  413.         };

  414.         Param param;

  415.         param.mode = param::RelayoutFormat::Mode::NCHW64_NCHW;

  416.         run(shapes, param);

  417.     }

  418. }

  419. 

  420. #endif

  421. 

  422. TEST_F(CUDA, RELAYOUT_FORMAT_NCHW4) {

  423.     Checker<RelayoutFormat> checker(handle_cuda());

  424.     UniformIntRNG rng{-50, 50};

  425.     param::RelayoutFormat param;

  426.     param.mode = param::RelayoutFormat::Mode::NCHW_NCHW4_IC_SMALL;

  427. 

  428.     for (DType dtype :

  429.          std::vector<DType>({dtype::QuantizedS8{0.1f}, dtype::Float32{}})) {

  430.         checker.set_dtype(0, dtype).set_dtype(1, dtype).set_rng(0, &rng);

  431. 

  432.         checker.set_param(param).execs({{2, 4, 35, 36}, {}});

  433.         checker.set_param(param).execs({{2, 3, 35, 36}, {}});

  434.         checker.set_param(param).execs({{2, 1, 35, 36}, {}});

  435.         param.mode = param::RelayoutFormat::Mode::

  436.                 NCHW_NCHW4_IC_SMALL_CONV_DENSE_WEIGHT;

  437.         checker.set_param(param).execs({{4, 3, 3, 3}, {}});

  438.         checker.set_param(param).execs({{4, 4, 3, 3}, {}});

  439.         checker.set_param(param).execs({{1, 4, 3, 3}, {}});

  440.     }

  441. }

  442. 

  443. // vim: syntax=cpp.doxygen