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: cfc41648a4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cfc41648a4'
${ noResults }
MegEngine/src/opr/test/nn_int.cpp

672 lines
28 kB
Raw Blame History 

  1. #include "megbrain/opr/nn_int.h"

  2. #include "megbrain/opr/basic_arith.h"

  3. #include "megbrain/opr/io.h"

  4. #include "megbrain/test/autocheck.h"

  5. #include "megbrain/test/helper.h"

  6. #include "megbrain/test/megdnn_helper.h"

  7. 

  8. using namespace mgb;

  9. 

  10. namespace {

  11. using Checker31 = AutoOprChecker<3, 1>;

  12. 

  13. std::unique_ptr<Checker31> make_elemwise_multi_type_checker3(

  14.         opr::ElemwiseMultiType::Mode mode, const std::array<DType, 3>& dtypes) {

  15.     using Checker = Checker31;

  16.     auto make_graph = [=](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  17.         auto as_type = [&dtypes, &inputs](size_t i) {

  18.             return opr::TypeCvt::make(inputs[i], dtypes[i]);

  19.         };

  20.         auto ovar = opr::ElemwiseMultiType::make(

  21.                 {as_type(0), as_type(1), as_type(2)}, mode);

  22.         return {opr::TypeCvt::make(ovar, dtype::Float32{})};

  23.     };

  24.     auto fwd = [=](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  25.         auto opr = megdnn_naive_handle()->create_operator<megdnn::ElemwiseMultiType>();

  26.         auto opr_typecvt = megdnn_naive_handle()->create_operator<megdnn::TypeCvt>();

  27.         opr->param() = {mode};

  28.         megdnn::TensorShapeArray inp_shapes(3);

  29.         megdnn::TensorNDArray inp_tensors(3);

  30.         HostTensorND cvt_val[3];

  31.         for (int i = 0; i < 3; ++i) {

  32.             cvt_val[i]

  33.                     .dtype(dtypes[i])

  34.                     .comp_node(inp[i]->comp_node())

  35.                     .resize(inp[i]->shape());

  36.             opr_typecvt->exec(inp[i]->as_megdnn(), cvt_val[i].as_megdnn());

  37.             inp_shapes[i] = inp[i]->shape();

  38.             inp_tensors[i] = cvt_val[i].as_megdnn();

  39.         }

  40.         TensorShape out_shape;

  41.         megdnn::Elemwise::deduce_shape(inp_shapes, out_shape);

  42.         auto trait = megdnn::ElemwiseMultiType::ModeTrait::from_mode(mode);

  43.         DType dtype;

  44.         trait.check_out(dtype, false);

  45.         HostTensorND tmp_out{inp[0]->comp_node(), out_shape, dtype};

  46.         opr->exec(inp_tensors, tmp_out.as_megdnn());

  47.         dest[0].resize(out_shape);

  48.         opr_typecvt->exec(tmp_out.as_megdnn(), dest[0].as_megdnn());

  49.     };

  50.     return std::make_unique<Checker>(make_graph, fwd);

  51. }

  52. }  // anonymous namespace

  53. 

  54. TEST(TestOprElemwiseMultiType, Fma3Int16x32x32x32) {

  55.     make_elemwise_multi_type_checker3(

  56.             opr::ElemwiseMultiType::Mode::FUSE_MUL_ADD3_INT16x32x32x32,

  57.             {dtype::Int16{}, dtype::Int32{}, dtype::Int32{}})

  58.             ->disable_grad_check()

  59.             .run({TensorShape{3, 4, 5}, {1, 4, 1}, {1, 4, 1}})

  60.             .run({TensorShape{1, 4, 5}, {1, 4, 1}, {1, 4, 1}})

  61.             .run({TensorShape{3, 4, 5}, {3, 4, 1}, {3, 4, 1}});

  62. }

  63. 

  64. TEST(TestOprElemwiseMultiType, Fma3IXxf32xf32xi8) {

  65.     std::array<DType, 3> src_types{dtype::Int8{}, dtype::Int16{}, dtype::Int32{}};

  66.     for (auto src_type : src_types) {

  67.         make_elemwise_multi_type_checker3(

  68.                 opr::ElemwiseMultiType::Mode::FUSE_MUL_ADD3_IXxF32xF32xI8,

  69.                 {src_type, dtype::Float32{}, dtype::Float32{}})

  70.                 ->disable_grad_check()

  71.                 .run({TensorShape{3, 4}, {3, 4}, {3, 4}})

  72.                 .run({TensorShape{3, 4}, {1, 4}, {1, 4}})

  73.                 .run({TensorShape{9, 4, 8}, {1, 4, 8}, {1, 4, 8}});

  74.     }

  75. }

  76. 

  77. TEST(TestOprElemwiseMultiType, QuantizedModeBinary_IS8_OS32) {

  78.     using Checker = AutoOprChecker<2, 1>;

  79.     DType x_dtype = dtype::QuantizedS8(0.15f);

  80.     DType y_dtype = dtype::QuantizedS8(0.20f);

  81.     DType z_dtype = dtype::QuantizedS32(0.15f);

  82.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  83.     for (auto mode : {Mode::QFUSE_ADD_RELU, Mode::QADD, Mode::QMUL}) {

  84.         auto make_graph =

  85.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  86.             OperatorNodeConfig config{z_dtype};

  87.             auto cpu = CompNode::load("cpux");

  88.             auto a = opr::Copy::make(inputs[0], cpu);

  89.             auto b = opr::Copy::make(inputs[1], cpu);

  90.             auto y = opr::ElemwiseMultiType::make(

  91.                     {opr::TypeCvt::make(a, x_dtype), opr::TypeCvt::make(b, y_dtype)},

  92.                     {mode}, config);

  93.             y = opr::TypeCvt::make(y, dtype::Float32());

  94.             return {y};

  95.         };

  96.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  97.             auto cg = ComputingGraph::make();

  98.             cg->options().graph_opt_level = 0;

  99.             auto x = opr::TypeCvt::make(

  100.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  101.             auto y = opr::TypeCvt::make(

  102.                     opr::Host2DeviceCopy::make(*cg, inp[1]), y_dtype);

  103.             SymbolVar z;

  104.             if (mode == Mode::QMUL) {

  105.                 z = opr::TypeCvt::make(x, dtype::Float32()) *

  106.                     opr::TypeCvt::make(y, dtype::Float32());

  107.                 z = opr::TypeCvt::make(z, z_dtype);

  108.             }

  109.             if (mode == Mode::QADD) {

  110.                 z = opr::TypeCvt::make(x, dtype::Float32()) +

  111.                     opr::TypeCvt::make(y, dtype::Float32());

  112.                 z = opr::TypeCvt::make(z, z_dtype);

  113.             }

  114.             if (mode == Mode::QFUSE_ADD_RELU) {

  115.                 z = opr::TypeCvt::make(x, dtype::Float32()) +

  116.                     opr::TypeCvt::make(y, dtype::Float32());

  117.                 z = opr::Elemwise::make({z}, {opr::Elemwise::Mode::RELU});

  118.                 z = opr::TypeCvt::make(z, z_dtype);

  119.             }

  120.             z = opr::TypeCvt::make(z, dtype::Float32());

  121.             auto func = cg->compile({make_callback_copy(z, dest[0])});

  122.             func->execute().wait();

  123.         };

  124.         Checker checker{make_graph, fwd};

  125.         Checker::RunOptions options;

  126.         options.outputs_max_err = 0.2;

  127.         checker.disable_grad_check()

  128.                 .run({TensorShape{3, 4}, {3, 4}})

  129.                 .run({TensorShape{3, 4}, {1, 4}})

  130.                 .run({TensorShape{9, 4, 8}, {1, 4, 8}}, options);

  131.     }

  132. }

  133. 

  134. auto gen_postive = [](HostTensorND& dest) {

  135.     HostTensorGenerator<dtype::Float32, RandomDistribution::UNIFORM> mask_generator{

  136.             0.f, FLT_MAX};

  137.     dest = *mask_generator(dest.shape(), dest.comp_node());

  138. };

  139. //! \warning: asin and acos has lower precision,

  140. //! they may produce nan.

  141. auto gen_asin_acos = [](HostTensorND& dest) {

  142.     HostTensorGenerator<dtype::Float32, RandomDistribution::UNIFORM> mask_generator{

  143.             -0.5f, 0.5f};

  144.     dest = *mask_generator(dest.shape(), dest.comp_node());

  145. };

  146. //! \warning: erfinv and erfcinv has lower precision,

  147. //! should give them more strict input.

  148. auto gen_erfinv = [](HostTensorND& dest) {

  149.     HostTensorGenerator<dtype::Float32, RandomDistribution::UNIFORM> mask_generator{

  150.             -0.5f, 0.5f};

  151.     dest = *mask_generator(dest.shape(), dest.comp_node());

  152. };

  153. auto gen_erfcinv = [](HostTensorND& dest) {

  154.     HostTensorGenerator<dtype::Float32, RandomDistribution::UNIFORM> mask_generator{

  155.             0.5f, 1.5f};

  156.     dest = *mask_generator(dest.shape(), dest.comp_node());

  157. };

  158. 

  159. #define MAKE_UNARY(_MODE)                                            \

  160.     case Mode::Q##_MODE:                                             \

  161.         d = opr::Elemwise::make({xf}, {opr::Elemwise::Mode::_MODE}); \

  162.         break

  163. TEST(TestOprElemwiseMultiType, QuantizedModeUnary_IS8_OS8) {

  164.     using Checker = AutoOprChecker<1, 1>;

  165.     DType x_dtype = dtype::QuantizedS8(1.15f);

  166.     DType d_dtype = dtype::QuantizedS8(2.00f);

  167.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  168.     for (auto mode :

  169.          {Mode::QRELU,      Mode::QABS,    Mode::QSIGMOID, Mode::QEXP,   Mode::QTANH,

  170.           Mode::QNEGATE,    Mode::QACOS,   Mode::QASIN,    Mode::QCEIL,  Mode::QCOS,

  171.           Mode::QEXPM1,     Mode::QFLOOR,  Mode::QLOG,     Mode::QLOG1P, Mode::QSIN,

  172.           Mode::QROUND,     Mode::QERF,    Mode::QERFINV,  Mode::QERFC,  Mode::QERFCINV,

  173.           Mode::QFAST_TANH, Mode::QH_SWISH}) {

  174.         auto make_graph =

  175.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  176.             OperatorNodeConfig config{d_dtype};

  177.             auto cpu = CompNode::load("cpux");

  178.             auto a = opr::Copy::make(inputs[0], cpu);

  179.             auto d = opr::ElemwiseMultiType::make(

  180.                     {opr::TypeCvt::make(a, x_dtype)}, {mode}, config);

  181.             d = opr::TypeCvt::make(d, dtype::Float32());

  182.             return {d};

  183.         };

  184.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  185.             auto cg = ComputingGraph::make();

  186.             cg->options().graph_opt_level = 0;

  187.             auto x = opr::TypeCvt::make(

  188.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  189.             SymbolVar d;

  190.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  191.             switch (mode) {

  192.                 MAKE_UNARY(RELU);

  193.                 MAKE_UNARY(ABS);

  194.                 MAKE_UNARY(SIGMOID);

  195.                 MAKE_UNARY(EXP);

  196.                 MAKE_UNARY(TANH);

  197.                 MAKE_UNARY(FAST_TANH);

  198.                 MAKE_UNARY(NEGATE);

  199.                 MAKE_UNARY(ACOS);

  200.                 MAKE_UNARY(ASIN);

  201.                 MAKE_UNARY(CEIL);

  202.                 MAKE_UNARY(COS);

  203.                 MAKE_UNARY(EXPM1);

  204.                 MAKE_UNARY(FLOOR);

  205.                 MAKE_UNARY(LOG);

  206.                 MAKE_UNARY(LOG1P);

  207.                 MAKE_UNARY(SIN);

  208.                 MAKE_UNARY(ROUND);

  209.                 MAKE_UNARY(ERF);

  210.                 MAKE_UNARY(ERFINV);

  211.                 MAKE_UNARY(ERFC);

  212.                 MAKE_UNARY(ERFCINV);

  213.                 MAKE_UNARY(H_SWISH);

  214.                 default:

  215.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  216.                     break;

  217.             }

  218.             d = opr::TypeCvt::make(d, d_dtype);

  219.             d = opr::TypeCvt::make(d, dtype::Float32());

  220.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  221.             func->execute().wait();

  222.         };

  223.         Checker checker{make_graph, fwd};

  224.         switch (mode) {

  225.             case Mode::QACOS:

  226.             case Mode::QASIN:

  227.                 checker.set_input_generator(0, gen_asin_acos);

  228.                 break;

  229.             case Mode::QLOG:

  230.             case Mode::QLOG1P:

  231.                 checker.set_input_generator(0, gen_postive);

  232.                 break;

  233.             case Mode::QERFINV:

  234.                 checker.set_input_generator(0, gen_erfinv);

  235.                 break;

  236.             case Mode::QERFCINV:

  237.                 checker.set_input_generator(0, gen_erfcinv);

  238.                 break;

  239.             default:

  240.                 break;

  241.         }

  242.         Checker::RunOptions options;

  243.         options.outputs_max_err = 0.2;

  244.         checker.disable_grad_check()

  245.                 .run({TensorShape{3, 4}})

  246.                 .run({TensorShape{4, 8}})

  247.                 .run({TensorShape{9, 4, 8}}, options);

  248.     }

  249. }

  250. 

  251. TEST(TestOprElemwiseMultiType, QuantizedModeUnary_I8Asymm_O8Asymm) {

  252.     using Checker = AutoOprChecker<1, 1>;

  253.     DType x_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  254.     DType d_dtype = dtype::Quantized8Asymm(2.00f, static_cast<uint8_t>(128));

  255.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  256.     for (auto mode :

  257.          {Mode::QRELU,     Mode::QABS,   Mode::QSIGMOID, Mode::QEXP,   Mode::QTANH,

  258.           Mode::QNEGATE,   Mode::QACOS,  Mode::QASIN,    Mode::QCEIL,  Mode::QCOS,

  259.           Mode::QEXPM1,    Mode::QFLOOR, Mode::QLOG,     Mode::QLOG1P, Mode::QSIN,

  260.           Mode::QROUND,    Mode::QERF,   Mode::QERFINV,  Mode::QERFC,  Mode::QERFCINV,

  261.           Mode::QFAST_TANH}) {

  262.         auto make_graph =

  263.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  264.             OperatorNodeConfig config{d_dtype};

  265.             auto cpu = CompNode::load("cpux");

  266.             auto a = opr::Copy::make(inputs[0], cpu);

  267.             auto d = opr::ElemwiseMultiType::make(

  268.                     {opr::TypeCvt::make(a, x_dtype)}, {mode}, config);

  269.             d = opr::TypeCvt::make(d, dtype::Float32());

  270.             return {d};

  271.         };

  272.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  273.             auto cg = ComputingGraph::make();

  274.             cg->options().graph_opt_level = 0;

  275.             auto x = opr::TypeCvt::make(

  276.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  277.             SymbolVar d;

  278.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  279.             switch (mode) {

  280.                 MAKE_UNARY(RELU);

  281.                 MAKE_UNARY(ABS);

  282.                 MAKE_UNARY(SIGMOID);

  283.                 MAKE_UNARY(EXP);

  284.                 MAKE_UNARY(TANH);

  285.                 MAKE_UNARY(FAST_TANH);

  286.                 MAKE_UNARY(NEGATE);

  287.                 MAKE_UNARY(ACOS);

  288.                 MAKE_UNARY(ASIN);

  289.                 MAKE_UNARY(CEIL);

  290.                 MAKE_UNARY(COS);

  291.                 MAKE_UNARY(EXPM1);

  292.                 MAKE_UNARY(FLOOR);

  293.                 MAKE_UNARY(LOG);

  294.                 MAKE_UNARY(LOG1P);

  295.                 MAKE_UNARY(SIN);

  296.                 MAKE_UNARY(ROUND);

  297.                 MAKE_UNARY(ERF);

  298.                 MAKE_UNARY(ERFINV);

  299.                 MAKE_UNARY(ERFC);

  300.                 MAKE_UNARY(ERFCINV);

  301.                 default:

  302.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  303.                     break;

  304.             }

  305.             d = opr::TypeCvt::make(d, d_dtype);

  306.             d = opr::TypeCvt::make(d, dtype::Float32());

  307.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  308.             func->execute().wait();

  309.         };

  310.         Checker checker{make_graph, fwd};

  311.         switch (mode) {

  312.             case Mode::QACOS:

  313.             case Mode::QASIN:

  314.                 checker.set_input_generator(0, gen_asin_acos);

  315.                 break;

  316.             case Mode::QLOG:

  317.             case Mode::QLOG1P:

  318.                 checker.set_input_generator(0, gen_postive);

  319.                 break;

  320.             case Mode::QERFINV:

  321.                 checker.set_input_generator(0, gen_erfinv);

  322.                 break;

  323.             case Mode::QERFCINV:

  324.                 checker.set_input_generator(0, gen_erfcinv);

  325.                 break;

  326.             default:

  327.                 break;

  328.         }

  329.         Checker::RunOptions options;

  330.         options.outputs_max_err = 0.2;

  331.         checker.disable_grad_check()

  332.                 .run({TensorShape{3, 4}})

  333.                 .run({TensorShape{4, 8}})

  334.                 .run({TensorShape{9, 4, 8}}, options);

  335.     }

  336. }

  337. #undef MAKE_UANRY

  338. 

  339. #define MAKE_BINARY(_MODE)                                               \

  340.     case Mode::Q##_MODE:                                                 \

  341.         d = opr::Elemwise::make({xf, yf}, {opr::Elemwise::Mode::_MODE}); \

  342.         break

  343. TEST(TestOprElemwiseMultiType, QuantizedModeBinary_IS8_OS8) {

  344.     using Checker = AutoOprChecker<2, 1>;

  345.     DType x_dtype = dtype::QuantizedS8(1.15f);

  346.     DType y_dtype = dtype::QuantizedS8(2.0f);

  347.     DType d_dtype = dtype::QuantizedS8(1.15f);

  348.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  349.     for (auto mode :

  350.          {Mode::QFUSE_ADD_RELU,

  351.           Mode::QADD,

  352.           Mode::QMUL,

  353.           Mode::QMIN,

  354.           Mode::QMAX,

  355.           Mode::QSUB,

  356.           Mode::QTRUE_DIV,

  357.           Mode::QFUSE_ADD_SIGMOID,

  358.           Mode::QFUSE_ADD_TANH,

  359.           Mode::QABS_GRAD,

  360.           Mode::QFLOOR_DIV,

  361.           Mode::QMOD,

  362.           Mode::QSIGMOID_GRAD,

  363.           Mode::QSWITCH_GT0,

  364.           Mode::QTANH_GRAD,

  365.           Mode::QLT,

  366.           Mode::QLEQ,

  367.           Mode::QEQ,

  368.           Mode::QPOW,

  369.           Mode::QLOG_SUM_EXP,

  370.           Mode::QFAST_TANH_GRAD,

  371.           Mode::QATAN2}) {

  372.         auto make_graph =

  373.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  374.             OperatorNodeConfig config{d_dtype};

  375.             auto cpu = CompNode::load("cpux");

  376.             auto a = opr::Copy::make(inputs[0], cpu);

  377.             auto b = opr::Copy::make(inputs[1], cpu);

  378.             auto d = opr::ElemwiseMultiType::make(

  379.                     {opr::TypeCvt::make(a, x_dtype), opr::TypeCvt::make(b, y_dtype)},

  380.                     {mode}, config);

  381.             d = opr::TypeCvt::make(d, dtype::Float32());

  382.             return {d};

  383.         };

  384.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  385.             auto cg = ComputingGraph::make();

  386.             cg->options().graph_opt_level = 0;

  387.             auto x = opr::TypeCvt::make(

  388.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  389.             auto y = opr::TypeCvt::make(

  390.                     opr::Host2DeviceCopy::make(*cg, inp[1]), y_dtype);

  391.             SymbolVar d;

  392.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  393.             auto yf = opr::TypeCvt::make(y, dtype::Float32());

  394.             switch (mode) {

  395.                 MAKE_BINARY(FUSE_ADD_RELU);

  396.                 MAKE_BINARY(ADD);

  397.                 MAKE_BINARY(MUL);

  398.                 MAKE_BINARY(MIN);

  399.                 MAKE_BINARY(MAX);

  400.                 MAKE_BINARY(SUB);

  401.                 MAKE_BINARY(TRUE_DIV);

  402.                 MAKE_BINARY(FUSE_ADD_SIGMOID);

  403.                 MAKE_BINARY(FUSE_ADD_TANH);

  404.                 MAKE_BINARY(ABS_GRAD);

  405.                 MAKE_BINARY(FLOOR_DIV);

  406.                 MAKE_BINARY(MOD);

  407.                 MAKE_BINARY(SIGMOID_GRAD);

  408.                 MAKE_BINARY(SWITCH_GT0);

  409.                 MAKE_BINARY(TANH_GRAD);

  410.                 MAKE_BINARY(LT);

  411.                 MAKE_BINARY(LEQ);

  412.                 MAKE_BINARY(EQ);

  413.                 MAKE_BINARY(POW);

  414.                 MAKE_BINARY(LOG_SUM_EXP);

  415.                 MAKE_BINARY(FAST_TANH_GRAD);

  416.                 MAKE_BINARY(ATAN2);

  417.                 default:

  418.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  419.                     break;

  420.             }

  421.             d = opr::TypeCvt::make(d, d_dtype);

  422.             d = opr::TypeCvt::make(d, dtype::Float32());

  423.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  424.             func->execute().wait();

  425.         };

  426.         Checker checker{make_graph, fwd};

  427.         switch (mode) {

  428.             case Mode::QTRUE_DIV:

  429.             case Mode::QMOD:

  430.             case Mode::QFLOOR_DIV:

  431.                 checker.set_input_generator(1, gen_postive);

  432.                 break;

  433.             default:

  434.                 break;

  435.         }

  436.         Checker::RunOptions options;

  437.         options.outputs_max_err = 0.2;

  438.         checker.disable_grad_check()

  439.                 .run({TensorShape{3, 4}, {3, 4}})

  440.                 .run({TensorShape{4, 8}, {1, 1}})

  441.                 .run({TensorShape{9, 4, 8}, {9, 4, 8}}, options);

  442.     }

  443. }

  444. 

  445. TEST(TestOprElemwiseMultiType, QuantizedModeBinary_I8Asymm_O8Asymm) {

  446.     using Checker = AutoOprChecker<2, 1>;

  447.     DType x_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  448.     DType y_dtype = dtype::Quantized8Asymm(2.0f, static_cast<uint8_t>(128));

  449.     DType d_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  450.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  451.     for (auto mode :

  452.          {Mode::QFUSE_ADD_RELU,

  453.           Mode::QADD,

  454.           Mode::QMUL,

  455.           Mode::QMIN,

  456.           Mode::QMAX,

  457.           Mode::QSUB,

  458.           Mode::QTRUE_DIV,

  459.           Mode::QFUSE_ADD_SIGMOID,

  460.           Mode::QFUSE_ADD_TANH,

  461.           Mode::QFUSE_ADD_H_SWISH,

  462.           Mode::QABS_GRAD,

  463.           Mode::QFLOOR_DIV,

  464.           Mode::QMOD,

  465.           Mode::QSIGMOID_GRAD,

  466.           Mode::QSWITCH_GT0,

  467.           Mode::QTANH_GRAD,

  468.           Mode::QLT,

  469.           Mode::QLEQ,

  470.           Mode::QEQ,

  471.           Mode::QPOW,

  472.           Mode::QLOG_SUM_EXP,

  473.           Mode::QFAST_TANH_GRAD,

  474.           Mode::QATAN2}) {

  475.         auto make_graph =

  476.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  477.             OperatorNodeConfig config{d_dtype};

  478.             auto cpu = CompNode::load("cpux");

  479.             auto a = opr::Copy::make(inputs[0], cpu);

  480.             auto b = opr::Copy::make(inputs[1], cpu);

  481.             auto d = opr::ElemwiseMultiType::make(

  482.                     {opr::TypeCvt::make(a, x_dtype), opr::TypeCvt::make(b, y_dtype)},

  483.                     {mode}, config);

  484.             d = opr::TypeCvt::make(d, dtype::Float32());

  485.             return {d};

  486.         };

  487.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  488.             auto cg = ComputingGraph::make();

  489.             cg->options().graph_opt_level = 0;

  490.             auto x = opr::TypeCvt::make(

  491.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  492.             auto y = opr::TypeCvt::make(

  493.                     opr::Host2DeviceCopy::make(*cg, inp[1]), y_dtype);

  494.             SymbolVar d;

  495.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  496.             auto yf = opr::TypeCvt::make(y, dtype::Float32());

  497.             switch (mode) {

  498.                 MAKE_BINARY(FUSE_ADD_RELU);

  499.                 MAKE_BINARY(ADD);

  500.                 MAKE_BINARY(MUL);

  501.                 MAKE_BINARY(MIN);

  502.                 MAKE_BINARY(MAX);

  503.                 MAKE_BINARY(SUB);

  504.                 MAKE_BINARY(TRUE_DIV);

  505.                 MAKE_BINARY(FUSE_ADD_SIGMOID);

  506.                 MAKE_BINARY(FUSE_ADD_TANH);

  507.                 MAKE_BINARY(FUSE_ADD_H_SWISH);

  508.                 MAKE_BINARY(ABS_GRAD);

  509.                 MAKE_BINARY(FLOOR_DIV);

  510.                 MAKE_BINARY(MOD);

  511.                 MAKE_BINARY(SIGMOID_GRAD);

  512.                 MAKE_BINARY(SWITCH_GT0);

  513.                 MAKE_BINARY(TANH_GRAD);

  514.                 MAKE_BINARY(LT);

  515.                 MAKE_BINARY(LEQ);

  516.                 MAKE_BINARY(EQ);

  517.                 MAKE_BINARY(POW);

  518.                 MAKE_BINARY(LOG_SUM_EXP);

  519.                 MAKE_BINARY(FAST_TANH_GRAD);

  520.                 MAKE_BINARY(ATAN2);

  521.                 default:

  522.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  523.                     break;

  524.             }

  525.             d = opr::TypeCvt::make(d, d_dtype);

  526.             d = opr::TypeCvt::make(d, dtype::Float32());

  527.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  528.             func->execute().wait();

  529.         };

  530.         Checker checker{make_graph, fwd};

  531.         switch (mode) {

  532.             case Mode::QTRUE_DIV:

  533.             case Mode::QMOD:

  534.             case Mode::QFLOOR_DIV:

  535.                 checker.set_input_generator(1, gen_postive);

  536.                 break;

  537.             default:

  538.                 break;

  539.         }

  540.         Checker::RunOptions options;

  541.         options.outputs_max_err = 0.2;

  542.         checker.disable_grad_check()

  543.                 .run({TensorShape{3, 4}, {3, 4}})

  544.                 .run({TensorShape{4, 8}, {1, 1}})

  545.                 .run({TensorShape{9, 4, 8}, {9, 4, 8}}, options);

  546.     }

  547. }

  548. #undef MAKE_BINARY

  549. 

  550. #define MAKE_TERNARY(_MODE)                                                  \

  551.     case Mode::Q##_MODE:                                                     \

  552.         d = opr::Elemwise::make({xf, yf, zf}, {opr::Elemwise::Mode::_MODE}); \

  553.         break

  554. TEST(TestOprElemwiseMultiType, QuantizedModeTernary_IS8_OS8) {

  555.     using Checker = AutoOprChecker<3, 1>;

  556.     DType x_dtype = dtype::QuantizedS8(1.15f);

  557.     DType y_dtype = dtype::QuantizedS8(2.0f);

  558.     DType z_dtype = dtype::QuantizedS8(1.15f);

  559.     DType d_dtype = dtype::QuantizedS8(1.15f);

  560.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  561.     for (auto mode : {Mode::QFUSE_MUL_ADD3, Mode::QCOND_LEQ_MOV}) {

  562.         auto make_graph =

  563.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  564.             OperatorNodeConfig config{d_dtype};

  565.             auto cpu = CompNode::load("cpux");

  566.             auto a = opr::Copy::make(inputs[0], cpu);

  567.             auto b = opr::Copy::make(inputs[1], cpu);

  568.             auto c = opr::Copy::make(inputs[2], cpu);

  569.             auto d = opr::ElemwiseMultiType::make(

  570.                     {opr::TypeCvt::make(a, x_dtype), opr::TypeCvt::make(b, y_dtype),

  571.                      opr::TypeCvt::make(c, z_dtype)},

  572.                     {mode}, config);

  573.             d = opr::TypeCvt::make(d, dtype::Float32());

  574.             return {d};

  575.         };

  576.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  577.             auto cg = ComputingGraph::make();

  578.             cg->options().graph_opt_level = 0;

  579.             auto x = opr::TypeCvt::make(

  580.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  581.             auto y = opr::TypeCvt::make(

  582.                     opr::Host2DeviceCopy::make(*cg, inp[1]), y_dtype);

  583.             auto z = opr::TypeCvt::make(

  584.                     opr::Host2DeviceCopy::make(*cg, inp[2]), z_dtype);

  585.             SymbolVar d;

  586.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  587.             auto yf = opr::TypeCvt::make(y, dtype::Float32());

  588.             auto zf = opr::TypeCvt::make(z, dtype::Float32());

  589.             switch (mode) {

  590.                 MAKE_TERNARY(FUSE_MUL_ADD3);

  591.                 MAKE_TERNARY(COND_LEQ_MOV);

  592.                 MAKE_TERNARY(COND_LT_MOV);

  593.                 default:

  594.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  595.                     break;

  596.             }

  597.             d = opr::TypeCvt::make(d, d_dtype);

  598.             d = opr::TypeCvt::make(d, dtype::Float32());

  599.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  600.             func->execute().wait();

  601.         };

  602.         Checker checker{make_graph, fwd};

  603.         Checker::RunOptions options;

  604.         options.outputs_max_err = 0.2;

  605.         checker.disable_grad_check()

  606.                 .run({TensorShape{3, 4}, {3, 4}, {3, 4}})

  607.                 .run({TensorShape{4, 8}, {4, 8}, {4, 8}})

  608.                 .run({TensorShape{9, 4, 8}, {9, 4, 8}, {9, 4, 8}}, options);

  609.     }

  610. }

  611. 

  612. TEST(TestOprElemwiseMultiType, QuantizedModeTernary_I8Asymm_O8Asymm) {

  613.     using Checker = AutoOprChecker<3, 1>;

  614.     DType x_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  615.     DType y_dtype = dtype::Quantized8Asymm(2.0f, static_cast<uint8_t>(128));

  616.     DType z_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  617.     DType d_dtype = dtype::Quantized8Asymm(1.15f, static_cast<uint8_t>(128));

  618.     using Mode = opr::ElemwiseMultiType::Param::Mode;

  619.     for (auto mode : {Mode::QFUSE_MUL_ADD3, Mode::QCOND_LEQ_MOV}) {

  620.         auto make_graph =

  621.                 [&](const Checker::SymInpArray& inputs) -> Checker::SymOutArray {

  622.             OperatorNodeConfig config{d_dtype};

  623.             auto cpu = CompNode::load("cpux");

  624.             auto a = opr::Copy::make(inputs[0], cpu);

  625.             auto b = opr::Copy::make(inputs[1], cpu);

  626.             auto c = opr::Copy::make(inputs[2], cpu);

  627.             auto d = opr::ElemwiseMultiType::make(

  628.                     {opr::TypeCvt::make(a, x_dtype), opr::TypeCvt::make(b, y_dtype),

  629.                      opr::TypeCvt::make(c, z_dtype)},

  630.                     {mode}, config);

  631.             d = opr::TypeCvt::make(d, dtype::Float32());

  632.             return {d};

  633.         };

  634.         auto fwd = [&](Checker::NumOutArray& dest, Checker::NumInpArray inp) {

  635.             auto cg = ComputingGraph::make();

  636.             cg->options().graph_opt_level = 0;

  637.             auto x = opr::TypeCvt::make(

  638.                     opr::Host2DeviceCopy::make(*cg, inp[0]), x_dtype);

  639.             auto y = opr::TypeCvt::make(

  640.                     opr::Host2DeviceCopy::make(*cg, inp[1]), y_dtype);

  641.             auto z = opr::TypeCvt::make(

  642.                     opr::Host2DeviceCopy::make(*cg, inp[2]), z_dtype);

  643.             SymbolVar d;

  644.             auto xf = opr::TypeCvt::make(x, dtype::Float32());

  645.             auto yf = opr::TypeCvt::make(y, dtype::Float32());

  646.             auto zf = opr::TypeCvt::make(z, dtype::Float32());

  647.             switch (mode) {

  648.                 MAKE_TERNARY(FUSE_MUL_ADD3);

  649.                 MAKE_TERNARY(COND_LEQ_MOV);

  650.                 MAKE_TERNARY(COND_LT_MOV);

  651.                 default:

  652.                     mgb_throw(InternalError, "Unknown ElemwiseMultiType Mode\n");

  653.                     break;

  654.             }

  655.             d = opr::TypeCvt::make(d, d_dtype);

  656.             d = opr::TypeCvt::make(d, dtype::Float32());

  657.             auto func = cg->compile({make_callback_copy(d, dest[0])});

  658.             func->execute().wait();

  659.         };

  660.         Checker checker{make_graph, fwd};

  661.         Checker::RunOptions options;

  662.         options.outputs_max_err = 0.2;

  663.         checker.disable_grad_check()

  664.                 .run({TensorShape{3, 4}, {3, 4}, {3, 4}})

  665.                 .run({TensorShape{4, 8}, {4, 8}, {4, 8}})

  666.                 .run({TensorShape{9, 4, 8}, {9, 4, 8}, {9, 4, 8}}, options);

  667.     }

  668. }

  669. #undef MAKE_TERNARY

  670. 

  671. // vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}