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

353 lines
13 kB
Raw Blame History 

  1. /**

  2.  * \file dnn/test/aarch64/warp_perspective.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 implied.

  10.  */

  11. 

  12. #include <string>

  13. #include <vector>

  14. #include "test/aarch64/fixture.h"

  15. 

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

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

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

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

  20. #include "test/common/task_record_check.h"

  21. 

  22. #include "test/common/warp_perspective.h"

  23. 

  24. namespace megdnn {

  25. namespace test {

  26. 

  27. TEST_F(AARCH64, WARP_PERSPECTIVE_CV) {

  28.     //! Just for the format NHWC

  29.     Checker<WarpPerspective, WarpPerspectiveMatIdxProxy> checker(handle());

  30.     param::WarpPerspective param;

  31.     class ResizeMatRNG : public RNG {

  32.         void gen(const TensorND& tensor_) override {

  33.             auto& gen = RandomState::generator();

  34.             std::uniform_real_distribution<dt_float32> pdist3(1.9f, 3.1f);

  35.             std::uniform_real_distribution<dt_float32> pdist(0.9f, 1.1f);

  36.             std::uniform_real_distribution<dt_float32> pdisth(0.4f, 0.6f);

  37.             std::uniform_real_distribution<dt_float32> ndist(-1.1f, -0.9f);

  38.             std::uniform_real_distribution<dt_float32> ndist3(-3.1f, -1.9f);

  39.             std::uniform_real_distribution<dt_float32> ndisth(-0.6f, -0.4f);

  40.             std::uniform_int_distribution<int> dice(0, 5);

  41.             float* ptr = tensor_.ptr<dt_float32>();

  42.             auto N = tensor_.layout.shape[0];

  43.             for (size_t n = 0; n < N; ++n) {

  44.                 for (size_t i = 0; i < 9; ++i) {

  45.                     switch (dice(gen)) {

  46.                         case 0:

  47.                             ptr[i] = pdist3(gen);

  48.                             break;

  49.                         case 1:

  50.                             ptr[i] = pdist(gen);

  51.                             break;

  52.                         case 2:

  53.                             ptr[i] = pdisth(gen);

  54.                             break;

  55.                         case 3:

  56.                             ptr[i] = ndist(gen);

  57.                             break;

  58.                         case 4:

  59.                             ptr[i] = ndist3(gen);

  60.                             break;

  61.                         case 5:

  62.                             ptr[i] = ndisth(gen);

  63.                             break;

  64.                     }

  65.                 }

  66.                 // is resize?

  67.                 if (n & 1) {

  68.                     ptr[1] = 0;

  69.                     ptr[3] = 0;

  70.                     ptr[6] = ptr[7] = 0;

  71.                 }

  72.                 ptr += 9;

  73.             }

  74.         }

  75.     } rng;

  76. 

  77.     using BMode = param::WarpPerspective::BorderMode;

  78.     param.format = param::WarpPerspective::Format::NHWC;

  79.     // add for nearest test

  80.     param.imode = param::WarpPerspective::InterpolationMode::NEAREST;

  81.     for (auto mode :

  82.          {BMode::REFLECT_101, BMode::REPLICATE, BMode::REFLECT, BMode::WRAP,

  83.           BMode::CONSTANT}) {

  84.         param.bmode = mode;

  85.         param.border_val = 1.737;

  86.         checker.set_param(param);

  87.         UniformIntRNG rng(0, 1);

  88.         checker.set_rng(2, &rng);

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

  90.         checker.exec({{2, 5, 5, 1}, {4, 3, 3}, {4}, {4, 5, 5, 1}});

  91.     }

  92.     // resize nan case

  93.     UniformFloatRNG rng_zero(0, 0);

  94.     checker.set_rng(1, &rng_zero);

  95.     {

  96.         param.bmode = BMode::CONSTANT;

  97.         param.border_val = 1.737;

  98.         checker.set_param(param);

  99.         UniformIntRNG rng(0, 999);

  100.         checker.set_rng(2, &rng);

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

  102.         checker.exec({{1000, 2, 10, 3}, {2000, 3, 3}, {2000}, {2000, 2, 12, 3}});

  103.     }

  104. 

  105.     // add linear test

  106.     param.imode = param::WarpPerspective::InterpolationMode::INTER_LINEAR;

  107.     for (auto mode :

  108.          {BMode::REFLECT_101, BMode::REPLICATE, BMode::REFLECT, BMode::WRAP,

  109.           BMode::CONSTANT}) {

  110.         param.bmode = mode;

  111.         param.border_val = 1.737;

  112.         checker.set_param(param);

  113.         UniformIntRNG rng(0, 9);

  114.         checker.set_rng(2, &rng);

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

  116.         checker.exec({{10, 128, 108, 3}, {20, 3, 3}, {20}, {20, 56, 128, 3}});

  117.     }

  118.     // resize nan case

  119.     checker.set_rng(1, &rng_zero);

  120.     {

  121.         param.bmode = BMode::CONSTANT;

  122.         param.border_val = 1.737;

  123.         checker.set_param(param);

  124.         UniformIntRNG rng(0, 999);

  125.         checker.set_rng(2, &rng);

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

  127.         checker.exec({{1000, 2, 10, 3}, {2000, 3, 3}, {2000}, {2000, 2, 12, 3}});

  128.     }

  129. 

  130.     auto args = warp_perspective::get_cv_args();

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

  132.         ConstValue rng(0.f);

  133.         checker.set_param(arg.param)

  134.                 .set_rng(2, &rng)

  135.                 .set_dtype(0, dtype::Uint8())

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

  137.                 .set_dtype(2, dtype::Int32())

  138.                 .set_dtype(3, dtype::Uint8())

  139.                 .execs({arg.src, arg.trans, arg.mat_idx, arg.dst});

  140.     }

  141. 

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

  143.         ConstValue rng(0.f);

  144.         checker.set_param(arg.param)

  145.                 .set_rng(2, &rng)

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

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

  148.                 .set_dtype(2, dtype::Int32())

  149.                 .set_dtype(3, dtype::Float32())

  150.                 .execs({arg.src, arg.trans, arg.mat_idx, arg.dst});

  151.     }

  152. }

  153. 

  154. TEST_F(AARCH64, WARP_PERSPECTIVE_CV_RECORD) {

  155.     //! Just for the format NHWC

  156.     TaskRecordChecker<WarpPerspective, WarpPerspectiveMatIdxProxy> checker(0);

  157.     param::WarpPerspective param;

  158.     class ResizeMatRNG : public RNG {

  159.         void gen(const TensorND& tensor_) override {

  160.             auto& gen = RandomState::generator();

  161.             std::uniform_real_distribution<dt_float32> pdist3(1.9f, 3.1f);

  162.             std::uniform_real_distribution<dt_float32> pdist(0.9f, 1.1f);

  163.             std::uniform_real_distribution<dt_float32> pdisth(0.4f, 0.6f);

  164.             std::uniform_real_distribution<dt_float32> ndist(-1.1f, -0.9f);

  165.             std::uniform_real_distribution<dt_float32> ndist3(-3.1f, -1.9f);

  166.             std::uniform_real_distribution<dt_float32> ndisth(-0.6f, -0.4f);

  167.             std::uniform_int_distribution<int> dice(0, 5);

  168.             float* ptr = tensor_.ptr<dt_float32>();

  169.             auto N = tensor_.layout.shape[0];

  170.             for (size_t n = 0; n < N; ++n) {

  171.                 for (size_t i = 0; i < 9; ++i) {

  172.                     switch (dice(gen)) {

  173.                         case 0:

  174.                             ptr[i] = pdist3(gen);

  175.                             break;

  176.                         case 1:

  177.                             ptr[i] = pdist(gen);

  178.                             break;

  179.                         case 2:

  180.                             ptr[i] = pdisth(gen);

  181.                             break;

  182.                         case 3:

  183.                             ptr[i] = ndist(gen);

  184.                             break;

  185.                         case 4:

  186.                             ptr[i] = ndist3(gen);

  187.                             break;

  188.                         case 5:

  189.                             ptr[i] = ndisth(gen);

  190.                             break;

  191.                     }

  192.                 }

  193.                 // is resize?

  194.                 if (n & 1) {

  195.                     ptr[1] = 0;

  196.                     ptr[3] = 0;

  197.                     ptr[6] = ptr[7] = 0;

  198.                 }

  199.                 ptr += 9;

  200.             }

  201.         }

  202.     } rng;

  203. 

  204.     using BMode = param::WarpPerspective::BorderMode;

  205.     param.format = param::WarpPerspective::Format::NHWC;

  206.     // add for nearest test

  207.     param.imode = param::WarpPerspective::InterpolationMode::NEAREST;

  208.     for (auto mode :

  209.          {BMode::REFLECT_101, BMode::REPLICATE, BMode::REFLECT, BMode::WRAP,

  210.           BMode::CONSTANT}) {

  211.         param.bmode = mode;

  212.         param.border_val = 1.737;

  213.         checker.set_param(param);

  214.         UniformIntRNG rng(0, 1);

  215.         checker.set_rng(2, &rng);

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

  217.         checker.exec({{2, 5, 5, 1}, {4, 3, 3}, {4}, {4, 5, 5, 1}});

  218.     }

  219.     // resize nan case

  220.     UniformFloatRNG rng_zero(0, 0);

  221.     checker.set_rng(1, &rng_zero);

  222.     {

  223.         param.bmode = BMode::CONSTANT;

  224.         param.border_val = 1.737;

  225.         checker.set_param(param);

  226.         UniformIntRNG rng(0, 999);

  227.         checker.set_rng(2, &rng);

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

  229.         checker.exec({{1000, 2, 10, 3}, {2000, 3, 3}, {2000}, {2000, 2, 12, 3}});

  230.     }

  231. 

  232.     // add linear test

  233.     param.imode = param::WarpPerspective::InterpolationMode::INTER_LINEAR;

  234.     for (auto mode :

  235.          {BMode::REFLECT_101, BMode::REPLICATE, BMode::REFLECT, BMode::WRAP,

  236.           BMode::CONSTANT}) {

  237.         param.bmode = mode;

  238.         param.border_val = 1.737;

  239.         checker.set_param(param);

  240.         UniformIntRNG rng(0, 9);

  241.         checker.set_rng(2, &rng);

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

  243.         checker.exec({{10, 128, 108, 3}, {20, 3, 3}, {20}, {20, 56, 128, 3}});

  244.     }

  245.     // resize nan case

  246.     checker.set_rng(1, &rng_zero);

  247.     {

  248.         param.bmode = BMode::CONSTANT;

  249.         param.border_val = 1.737;

  250.         checker.set_param(param);

  251.         UniformIntRNG rng(0, 999);

  252.         checker.set_rng(2, &rng);

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

  254.         checker.exec({{1000, 2, 10, 3}, {2000, 3, 3}, {2000}, {2000, 2, 12, 3}});

  255.     }

  256. 

  257.     auto args = warp_perspective::get_cv_args();

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

  259.         ConstValue rng(0.f);

  260.         checker.set_param(arg.param)

  261.                 .set_rng(2, &rng)

  262.                 .set_dtype(0, dtype::Uint8())

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

  264.                 .set_dtype(2, dtype::Int32())

  265.                 .set_dtype(3, dtype::Uint8())

  266.                 .execs({arg.src, arg.trans, arg.mat_idx, arg.dst});

  267.     }

  268. 

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

  270.         ConstValue rng(0.f);

  271.         checker.set_param(arg.param)

  272.                 .set_rng(2, &rng)

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

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

  275.                 .set_dtype(2, dtype::Int32())

  276.                 .set_dtype(3, dtype::Float32())

  277.                 .execs({arg.src, arg.trans, arg.mat_idx, arg.dst});

  278.     }

  279. }

  280. 

  281. #if MEGDNN_WITH_BENCHMARK

  282. TEST_F(AARCH64, BENCHMARK_WARP_PERSPECTIVE_FORWARD) {

  283.     Benchmarker<WarpPerspectiveForward> benchmarker(handle());

  284.     auto handle_naive = create_cpu_handle(2);

  285.     Benchmarker<WarpPerspectiveForward> benchmarker_naive(handle_naive.get());

  286.     constexpr size_t NR_RUN = 50;

  287. 

  288.     using BMode = param::WarpPerspective::BorderMode;

  289.     using IMode = param::WarpPerspective::InterpolationMode;

  290. 

  291.     WarpPerspective::Param param;

  292.     param.border_val = 0.3f;

  293.     param.format = param::WarpPerspective::Format::NHWC;

  294. 

  295.     auto run = [&](size_t N, size_t C, size_t IH, size_t IW, size_t OH, size_t OW,

  296.                    size_t scale) {

  297.         printf("src={%zu, %zu, %zu, %zu}, dst={%zu, %zu, %zu, %zu}\n", N, IH, IW, C, N,

  298.                OH, OW, C);

  299.         auto time_ms =

  300.                 benchmarker.exec({{N, IH, IW, C}, {N, 3, 3}, {N, OH, OW, C}}) / NR_RUN;

  301.         auto time_naive_ms =

  302.                 benchmarker_naive.exec({{N, IH, IW, C}, {N, 3, 3}, {N, OH, OW, C}}) /

  303.                 NR_RUN;

  304.         auto bandwidth = N * C * (scale * OH * OW) * dtype::Float32().size();

  305.         printf("aarch64: %.3f, perf: %.3f GBPS naive: %.3f, perf %.3f GBPS "

  306.                "speedup: %f\n",

  307.                time_ms, bandwidth / time_ms / 1e6, time_naive_ms,

  308.                bandwidth / time_naive_ms / 1e6, time_naive_ms / time_ms);

  309.     };

  310. 

  311.     std::vector<std::string> bmodestringmap = {

  312.             "REPLICATE", "REFLECT", "REFLECT_101", "WARP", "CONSTANT"};

  313. 

  314.     std::vector<std::string> imodestringmap = {"NEAREST", "INTER_LINEAR"};

  315.     size_t scales[2] = {2, 5};

  316. 

  317.     for (auto imode : {IMode::NEAREST, IMode::INTER_LINEAR}) {

  318.         for (auto bmode :

  319.              {BMode::REFLECT_101, BMode::REPLICATE, BMode::REFLECT, BMode::WRAP,

  320.               BMode::CONSTANT}) {

  321.             param.imode = imode;

  322.             param.bmode = bmode;

  323.             benchmarker.set_param(param).set_display(false).set_times(NR_RUN);

  324.             benchmarker_naive.set_param(param).set_display(false).set_times(NR_RUN);

  325.             size_t scale = scales[(int)imode];

  326.             printf("\n\n\n warpperspective InterpolationMode::%s "

  327.                    "BorderMode::%s start\n",

  328.                    imodestringmap[(int)imode].c_str(),

  329.                    bmodestringmap[(int)bmode].c_str());

  330.             for (auto&& shape : std::vector<std::pair<size_t, size_t>>{

  331.                          {700, 490},

  332.                          {500, 334},

  333.                          {472, 342},

  334.                          {448, 306},

  335.                          {626, 412},

  336.                          {140, 144},

  337.                          {120, 128},

  338.                          {180, 176}}) {

  339.                 for (size_t ch : {1, 2, 3}) {

  340.                     run(1, ch, shape.first, shape.second, 256, 256, scale);

  341.                 }

  342.             }

  343.         }

  344.     }

  345. }

  346. 

  347. #endif

  348. 

  349. }  // namespace test

  350. }  // namespace megdnn

  351. 

  352. // vim: syntax=cpp.doxygen