compiler/luci-interpreter/src/loader/KernelBuilder.test.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *    http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "loader/GraphLoader.h"
  18 #include "loader/KernelBuilder.h"
  19
  20 #include <kernels/Add.h>
  21 #include <kernels/ArgMax.h>
  22 #include <kernels/AveragePool2D.h>
  23 #include <kernels/Concatenation.h>
  24 #include <kernels/Conv2D.h>
  25 #include <kernels/DepthToSpace.h>
  26 #include <kernels/DepthwiseConv2D.h>
  27 #include <kernels/Elu.h>
  28 #include <kernels/FullyConnected.h>
  29 #include <kernels/L2Normalize.h>
  30 #include <kernels/L2Pool2D.h>
  31 #include <kernels/LeakyRelu.h>
  32 #include <kernels/LocalResponseNormalization.h>
  33 #include <kernels/Logistic.h>
  34 #include <kernels/MaxPool2D.h>
  35 #include <kernels/Mean.h>
  36 #include <kernels/Mul.h>
  37 #include <kernels/Pad.h>
  38 #include <kernels/Reshape.h>
  39 #include <kernels/Reverse.h>
  40 #include <kernels/Rsqrt.h>
  41 #include <kernels/Slice.h>
  42 #include <kernels/Softmax.h>
  43 #include <kernels/SpaceToDepth.h>
  44 #include <kernels/Split.h>
  45 #include <kernels/Sqrt.h>
  46 #include <kernels/Squeeze.h>
  47 #include <kernels/StridedSlice.h>
  48 #include <kernels/Tanh.h>
  49 #include <kernels/Transpose.h>
  50 #include <kernels/TransposeConv.h>
  51 #include <kernels/Unpack.h>
  52
  53 #include <gmock/gmock.h>
  54
  55 namespace luci_interpreter
  56 {
  57 namespace
  58 {
  59
  60 using namespace testing;
  61
  62 class KernelBuilderTest : public Test
  63 {
  64 protected:
  65   luci::CircleInput *createInputNode() { return createNode<luci::CircleInput>(); }
  66
  67   template <typename NodeT, typename... Args> NodeT *createNode(Args &&... args)
  68   {
  69     auto *node = _graph.nodes()->create<NodeT>(std::forward<Args>(args)...);
  70     // The actual type does not matter for the purpose of the tests.
  71     // NOTE The type is meaningless for nodes with multiple outputs (corresponding *Out nodes carry
  72     //  actual output types).
  73     node->dtype(loco::DataType::FLOAT32);
  74     return node;
  75   }
  76
  77   template <typename NodeOutT> NodeOutT *createNodeOut(loco::Node *node, int index)
  78   {
  79     auto *node_out = createNode<NodeOutT>();
  80     node_out->input(node);
  81     node_out->index(index);
  82     return node_out;
  83   }
  84
  85   template <typename KernelT> std::unique_ptr<KernelT> buildKernel(const luci::CircleNode *op)
  86   {
  87     std::unordered_map<const loco::Graph *, RuntimeGraph *> graph_to_runtime_graph;
  88
  89     RuntimeGraph runtime_graph(nullptr);
  90     RuntimeToIR runtime_to_ir;
  91     GraphLoader graph_loader(&_graph, &runtime_graph, runtime_to_ir, graph_to_runtime_graph,
  92                              _node_to_tensor);
  93     graph_loader.loadTensors();
  94
  95     KernelBuilder kernel_builder(graph_to_runtime_graph, _node_to_tensor);
  96
  97     auto kernel = op->accept(&kernel_builder);
  98     return std::unique_ptr<KernelT>(dynamic_cast<KernelT *>(kernel.release()));
  99   }
 100
 101   void checkTensor(const Tensor *tensor, const loco::Node *node)
 102   {
 103     EXPECT_THAT(tensor, Eq(_node_to_tensor.at(node)));
 104   }
 105
 106 private:
 107   loco::Graph _graph;
 108   std::unordered_map<const loco::Node *, Tensor *> _node_to_tensor;
 109 };
 110
 111 TEST_F(KernelBuilderTest, Add)
 112 {
 113   auto *input1 = createInputNode();
 114   auto *input2 = createInputNode();
 115
 116   auto *op = createNode<luci::CircleAdd>();
 117   op->x(input1);
 118   op->y(input2);
 119
 120   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 121
 122   auto kernel = buildKernel<kernels::Add>(op);
 123   ASSERT_THAT(kernel, NotNull());
 124
 125   checkTensor(kernel->input1(), input1);
 126   checkTensor(kernel->input2(), input2);
 127   checkTensor(kernel->output(), op);
 128   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 129 }
 130
 131 TEST_F(KernelBuilderTest, ArgMax)
 132 {
 133   auto *input = createInputNode();
 134   auto *axis = createInputNode();
 135
 136   auto *op = createNode<luci::CircleArgMax>();
 137   op->input(input);
 138   op->dimension(axis);
 139
 140   op->output_type(loco::DataType::FLOAT32);
 141
 142   auto kernel = buildKernel<kernels::ArgMax>(op);
 143   ASSERT_THAT(kernel, NotNull());
 144
 145   checkTensor(kernel->input(), input);
 146   checkTensor(kernel->axis(), axis);
 147   checkTensor(kernel->output(), op);
 148   EXPECT_THAT(kernel->params().output_type, Eq(op->output_type()));
 149 }
 150
 151 TEST_F(KernelBuilderTest, AveragePool2D)
 152 {
 153   auto *input = createInputNode();
 154
 155   auto *op = createNode<luci::CircleAveragePool2D>();
 156   op->value(input);
 157
 158   op->padding(luci::Padding::SAME);
 159   op->filter()->h(11);
 160   op->filter()->w(13);
 161   op->stride()->h(17);
 162   op->stride()->w(19);
 163   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 164
 165   auto kernel = buildKernel<kernels::AveragePool2D>(op);
 166   ASSERT_THAT(kernel, NotNull());
 167
 168   checkTensor(kernel->input(), input);
 169   checkTensor(kernel->output(), op);
 170   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 171   EXPECT_THAT(kernel->params().filter_height, Eq(op->filter()->h()));
 172   EXPECT_THAT(kernel->params().filter_width, Eq(op->filter()->w()));
 173   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 174   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 175   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 176 }
 177
 178 TEST_F(KernelBuilderTest, Concatenation)
 179 {
 180   auto *input1 = createInputNode();
 181   auto *input2 = createInputNode();
 182
 183   auto *op = createNode<luci::CircleConcatenation>(2);
 184   op->values(0, input1);
 185   op->values(1, input2);
 186   op->axis(11);
 187
 188   auto kernel = buildKernel<kernels::Concatenation>(op);
 189   ASSERT_THAT(kernel, NotNull());
 190
 191   checkTensor(kernel->input(0), input1);
 192   checkTensor(kernel->input(1), input2);
 193   checkTensor(kernel->output(), op);
 194   EXPECT_THAT(kernel->params().axis, Eq(op->axis()));
 195 }
 196
 197 TEST_F(KernelBuilderTest, Conv2D)
 198 {
 199   auto *input = createInputNode();
 200   auto *filter = createInputNode();
 201   auto *bias = createInputNode();
 202
 203   auto *op = createNode<luci::CircleConv2D>();
 204   op->input(input);
 205   op->filter(filter);
 206   op->bias(bias);
 207
 208   op->padding(luci::Padding::SAME);
 209   op->stride()->h(11);
 210   op->stride()->w(13);
 211   op->dilation()->h(17);
 212   op->dilation()->w(19);
 213   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 214
 215   auto kernel = buildKernel<kernels::Conv2D>(op);
 216   ASSERT_THAT(kernel, NotNull());
 217
 218   checkTensor(kernel->input(), input);
 219   checkTensor(kernel->filter(), filter);
 220   checkTensor(kernel->bias(), bias);
 221   checkTensor(kernel->output(), op);
 222   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 223   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 224   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 225   EXPECT_THAT(kernel->params().dilation_height_factor, Eq(op->dilation()->h()));
 226   EXPECT_THAT(kernel->params().dilation_width_factor, Eq(op->dilation()->w()));
 227   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 228 }
 229
 230 TEST_F(KernelBuilderTest, DepthToSpace)
 231 {
 232   auto *input = createInputNode();
 233
 234   auto *op = createNode<luci::CircleDepthToSpace>();
 235   op->input(input);
 236
 237   op->block_size(11);
 238
 239   auto kernel = buildKernel<kernels::DepthToSpace>(op);
 240   ASSERT_THAT(kernel, NotNull());
 241
 242   checkTensor(kernel->input(), input);
 243   checkTensor(kernel->output(), op);
 244   EXPECT_THAT(kernel->params().block_size, Eq(op->block_size()));
 245 }
 246
 247 TEST_F(KernelBuilderTest, DepthwiseConv2D)
 248 {
 249   auto *input = createInputNode();
 250   auto *filter = createInputNode();
 251   auto *bias = createInputNode();
 252
 253   auto *op = createNode<luci::CircleDepthwiseConv2D>();
 254   op->input(input);
 255   op->filter(filter);
 256   op->bias(bias);
 257
 258   op->padding(luci::Padding::SAME);
 259   op->depthMultiplier(11);
 260   op->stride()->h(13);
 261   op->stride()->w(17);
 262   op->dilation()->h(19);
 263   op->dilation()->w(23);
 264   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 265
 266   auto kernel = buildKernel<kernels::DepthwiseConv2D>(op);
 267   ASSERT_THAT(kernel, NotNull());
 268
 269   checkTensor(kernel->input(), input);
 270   checkTensor(kernel->filter(), filter);
 271   checkTensor(kernel->bias(), bias);
 272   checkTensor(kernel->output(), op);
 273   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 274   EXPECT_THAT(kernel->params().depth_multiplier, Eq(op->depthMultiplier()));
 275   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 276   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 277   EXPECT_THAT(kernel->params().dilation_height_factor, Eq(op->dilation()->h()));
 278   EXPECT_THAT(kernel->params().dilation_width_factor, Eq(op->dilation()->w()));
 279   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 280 }
 281
 282 TEST_F(KernelBuilderTest, Elu)
 283 {
 284   auto *input = createInputNode();
 285
 286   auto *op = createNode<luci::CircleElu>();
 287   op->features(input);
 288
 289   auto kernel = buildKernel<kernels::Elu>(op);
 290   ASSERT_THAT(kernel, NotNull());
 291
 292   checkTensor(kernel->input(), input);
 293   checkTensor(kernel->output(), op);
 294 }
 295
 296 TEST_F(KernelBuilderTest, FullyConnected)
 297 {
 298   auto *input = createInputNode();
 299   auto *weights = createInputNode();
 300   auto *bias = createInputNode();
 301
 302   auto *op = createNode<luci::CircleFullyConnected>();
 303   op->input(input);
 304   op->weights(weights);
 305   op->bias(bias);
 306
 307   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 308
 309   auto kernel = buildKernel<kernels::FullyConnected>(op);
 310   ASSERT_THAT(kernel, NotNull());
 311
 312   checkTensor(kernel->input(), input);
 313   checkTensor(kernel->weights(), weights);
 314   checkTensor(kernel->bias(), bias);
 315   checkTensor(kernel->output(), op);
 316   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 317 }
 318
 319 TEST_F(KernelBuilderTest, L2Normalize)
 320 {
 321   auto *input = createInputNode();
 322
 323   auto *op = createNode<luci::CircleL2Normalize>();
 324   op->x(input);
 325
 326   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 327
 328   auto kernel = buildKernel<kernels::L2Normalize>(op);
 329   ASSERT_THAT(kernel, NotNull());
 330
 331   checkTensor(kernel->input(), input);
 332   checkTensor(kernel->output(), op);
 333   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 334 }
 335
 336 TEST_F(KernelBuilderTest, L2Pool2D)
 337 {
 338   auto *input = createInputNode();
 339
 340   auto *op = createNode<luci::CircleL2Pool2D>();
 341   op->value(input);
 342
 343   op->padding(luci::Padding::SAME);
 344   op->filter()->h(11);
 345   op->filter()->w(13);
 346   op->stride()->h(17);
 347   op->stride()->w(19);
 348   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 349
 350   auto kernel = buildKernel<kernels::L2Pool2D>(op);
 351   ASSERT_THAT(kernel, NotNull());
 352
 353   checkTensor(kernel->input(), input);
 354   checkTensor(kernel->output(), op);
 355   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 356   EXPECT_THAT(kernel->params().filter_height, Eq(op->filter()->h()));
 357   EXPECT_THAT(kernel->params().filter_width, Eq(op->filter()->w()));
 358   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 359   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 360   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 361 }
 362
 363 TEST_F(KernelBuilderTest, LeakyRelu)
 364 {
 365   auto *input = createInputNode();
 366
 367   auto *op = createNode<luci::CircleLeakyRelu>();
 368   op->features(input);
 369
 370   op->alpha(11.0f);
 371
 372   auto kernel = buildKernel<kernels::LeakyRelu>(op);
 373   ASSERT_THAT(kernel, NotNull());
 374
 375   checkTensor(kernel->input(), input);
 376   checkTensor(kernel->output(), op);
 377   EXPECT_THAT(kernel->params().alpha, Eq(op->alpha()));
 378 }
 379
 380 TEST_F(KernelBuilderTest, LocalResponseNormalization)
 381 {
 382   auto *input = createInputNode();
 383
 384   auto *op = createNode<luci::CircleLocalResponseNormalization>();
 385   op->input(input);
 386
 387   op->radius(11);
 388   op->bias(13.0f);
 389   op->alpha(15.0f);
 390   op->beta(17.0f);
 391
 392   auto kernel = buildKernel<kernels::LocalResponseNormalization>(op);
 393   ASSERT_THAT(kernel, NotNull());
 394
 395   checkTensor(kernel->input(), input);
 396   checkTensor(kernel->output(), op);
 397   EXPECT_THAT(kernel->params().radius, Eq(op->radius()));
 398   EXPECT_THAT(kernel->params().bias, Eq(op->bias()));
 399   EXPECT_THAT(kernel->params().alpha, Eq(op->alpha()));
 400   EXPECT_THAT(kernel->params().beta, Eq(op->beta()));
 401 }
 402
 403 TEST_F(KernelBuilderTest, Logistic)
 404 {
 405   auto *input = createInputNode();
 406
 407   auto *op = createNode<luci::CircleLogistic>();
 408   op->x(input);
 409
 410   auto kernel = buildKernel<kernels::Logistic>(op);
 411   ASSERT_THAT(kernel, NotNull());
 412
 413   checkTensor(kernel->input(), input);
 414   checkTensor(kernel->output(), op);
 415 }
 416
 417 TEST_F(KernelBuilderTest, MaxPool2D)
 418 {
 419   auto *input = createInputNode();
 420
 421   auto *op = createNode<luci::CircleMaxPool2D>();
 422   op->value(input);
 423
 424   op->padding(luci::Padding::SAME);
 425   op->filter()->h(11);
 426   op->filter()->w(13);
 427   op->stride()->h(17);
 428   op->stride()->w(19);
 429   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 430
 431   auto kernel = buildKernel<kernels::MaxPool2D>(op);
 432   ASSERT_THAT(kernel, NotNull());
 433
 434   checkTensor(kernel->input(), input);
 435   checkTensor(kernel->output(), op);
 436   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 437   EXPECT_THAT(kernel->params().filter_height, Eq(op->filter()->h()));
 438   EXPECT_THAT(kernel->params().filter_width, Eq(op->filter()->w()));
 439   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 440   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 441   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 442 }
 443
 444 TEST_F(KernelBuilderTest, Mean)
 445 {
 446   auto *input = createInputNode();
 447   auto *axes = createInputNode();
 448
 449   auto *op = createNode<luci::CircleMean>();
 450   op->input(input);
 451   op->reduction_indices(axes);
 452
 453   op->keep_dims(true);
 454
 455   auto kernel = buildKernel<kernels::Mean>(op);
 456   ASSERT_THAT(kernel, NotNull());
 457
 458   checkTensor(kernel->input(), input);
 459   checkTensor(kernel->axes(), axes);
 460   checkTensor(kernel->output(), op);
 461   EXPECT_THAT(kernel->params().keep_dims, Eq(op->keep_dims()));
 462 }
 463
 464 TEST_F(KernelBuilderTest, Mul)
 465 {
 466   auto *input1 = createInputNode();
 467   auto *input2 = createInputNode();
 468
 469   auto *op = createNode<luci::CircleMul>();
 470   op->x(input1);
 471   op->y(input2);
 472
 473   op->fusedActivationFunction(luci::FusedActFunc::RELU);
 474
 475   auto kernel = buildKernel<kernels::Mul>(op);
 476   ASSERT_THAT(kernel, NotNull());
 477
 478   checkTensor(kernel->input1(), input1);
 479   checkTensor(kernel->input2(), input2);
 480   checkTensor(kernel->output(), op);
 481   EXPECT_THAT(kernel->params().activation, Eq(op->fusedActivationFunction()));
 482 }
 483
 484 TEST_F(KernelBuilderTest, Pad)
 485 {
 486   auto *input = createInputNode();
 487   auto *paddings = createInputNode();
 488
 489   auto *op = createNode<luci::CirclePad>();
 490   op->input(input);
 491   op->paddings(paddings);
 492
 493   auto kernel = buildKernel<kernels::Pad>(op);
 494   ASSERT_THAT(kernel, NotNull());
 495
 496   checkTensor(kernel->input(), input);
 497   checkTensor(kernel->paddings(), paddings);
 498   checkTensor(kernel->output(), op);
 499 }
 500
 501 TEST_F(KernelBuilderTest, Reshape)
 502 {
 503   auto *input = createInputNode();
 504   auto *shape = createInputNode();
 505
 506   auto *op = createNode<luci::CircleReshape>();
 507   op->tensor(input);
 508   op->shape(shape);
 509
 510   auto kernel = buildKernel<kernels::Reshape>(op);
 511   ASSERT_THAT(kernel, NotNull());
 512
 513   checkTensor(kernel->input(), input);
 514   checkTensor(kernel->shape(), shape);
 515   checkTensor(kernel->output(), op);
 516 }
 517
 518 TEST_F(KernelBuilderTest, ReverseV2)
 519 {
 520   auto *input = createInputNode();
 521   auto *axes = createInputNode();
 522
 523   auto *op = createNode<luci::CircleReverseV2>();
 524   op->tensor(input);
 525   op->axis(axes);
 526
 527   auto kernel = buildKernel<kernels::Reverse>(op);
 528   ASSERT_THAT(kernel, NotNull());
 529
 530   checkTensor(kernel->input(), input);
 531   checkTensor(kernel->axes(), axes);
 532   checkTensor(kernel->output(), op);
 533 }
 534
 535 TEST_F(KernelBuilderTest, Rsqrt)
 536 {
 537   auto *input = createInputNode();
 538
 539   auto *op = createNode<luci::CircleRsqrt>();
 540   op->x(input);
 541
 542   auto kernel = buildKernel<kernels::Rsqrt>(op);
 543   ASSERT_THAT(kernel, NotNull());
 544
 545   checkTensor(kernel->input(), input);
 546   checkTensor(kernel->output(), op);
 547 }
 548
 549 TEST_F(KernelBuilderTest, Slice)
 550 {
 551   auto *input = createInputNode();
 552   auto *begin = createInputNode();
 553   auto *size = createInputNode();
 554
 555   auto *op = createNode<luci::CircleSlice>();
 556   op->input(input);
 557   op->begin(begin);
 558   op->size(size);
 559
 560   auto kernel = buildKernel<kernels::Slice>(op);
 561   ASSERT_THAT(kernel, NotNull());
 562
 563   checkTensor(kernel->input(), input);
 564   checkTensor(kernel->begin(), begin);
 565   checkTensor(kernel->size(), size);
 566   checkTensor(kernel->output(), op);
 567 }
 568
 569 TEST_F(KernelBuilderTest, Softmax)
 570 {
 571   auto *input = createInputNode();
 572
 573   auto *op = createNode<luci::CircleSoftmax>();
 574   op->logits(input);
 575
 576   op->beta(11.0f);
 577
 578   auto kernel = buildKernel<kernels::Softmax>(op);
 579   ASSERT_THAT(kernel, NotNull());
 580
 581   checkTensor(kernel->input(), input);
 582   checkTensor(kernel->output(), op);
 583   EXPECT_THAT(kernel->params().beta, Eq(op->beta()));
 584 }
 585
 586 TEST_F(KernelBuilderTest, SpaceToDepth)
 587 {
 588   auto *input = createInputNode();
 589
 590   auto *op = createNode<luci::CircleSpaceToDepth>();
 591   op->input(input);
 592
 593   op->block_size(11);
 594
 595   auto kernel = buildKernel<kernels::SpaceToDepth>(op);
 596   ASSERT_THAT(kernel, NotNull());
 597
 598   checkTensor(kernel->input(), input);
 599   checkTensor(kernel->output(), op);
 600   EXPECT_THAT(kernel->params().block_size, op->block_size());
 601 }
 602
 603 TEST_F(KernelBuilderTest, Split)
 604 {
 605   auto *axis = createInputNode();
 606   auto *input = createInputNode();
 607   auto *op = createNode<luci::CircleSplit>();
 608   auto *output1 = createNodeOut<luci::CircleSplitOut>(op, 0);
 609   auto *output2 = createNodeOut<luci::CircleSplitOut>(op, 1);
 610
 611   op->split_dim(axis);
 612   op->input(input);
 613
 614   op->num_split(2);
 615
 616   auto kernel = buildKernel<kernels::Split>(op);
 617   ASSERT_THAT(kernel, NotNull());
 618
 619   checkTensor(kernel->axis(), axis);
 620   checkTensor(kernel->input(), input);
 621   checkTensor(kernel->output(0), output1);
 622   checkTensor(kernel->output(1), output2);
 623 }
 624
 625 TEST_F(KernelBuilderTest, Sqrt)
 626 {
 627   auto *input = createInputNode();
 628
 629   auto *op = createNode<luci::CircleSqrt>();
 630   op->x(input);
 631
 632   auto kernel = buildKernel<kernels::Sqrt>(op);
 633   ASSERT_THAT(kernel, NotNull());
 634
 635   checkTensor(kernel->input(), input);
 636   checkTensor(kernel->output(), op);
 637 }
 638
 639 TEST_F(KernelBuilderTest, Squeeze)
 640 {
 641   auto *input = createInputNode();
 642
 643   auto *op = createNode<luci::CircleSqueeze>();
 644   op->input(input);
 645
 646   op->squeeze_dims({11, 13});
 647
 648   auto kernel = buildKernel<kernels::Squeeze>(op);
 649   ASSERT_THAT(kernel, NotNull());
 650
 651   checkTensor(kernel->input(), input);
 652   checkTensor(kernel->output(), op);
 653   EXPECT_THAT(kernel->params().squeeze_dims, ElementsAreArray(op->squeeze_dims()));
 654 }
 655
 656 TEST_F(KernelBuilderTest, StridedSlice)
 657 {
 658   auto *input = createInputNode();
 659   auto *begin = createInputNode();
 660   auto *end = createInputNode();
 661   auto *strides = createInputNode();
 662
 663   auto *op = createNode<luci::CircleStridedSlice>();
 664   op->input(input);
 665   op->begin(begin);
 666   op->end(end);
 667   op->strides(strides);
 668
 669   op->begin_mask(11);
 670   op->ellipsis_mask(13);
 671   op->end_mask(17);
 672   op->new_axis_mask(19);
 673   op->shrink_axis_mask(23);
 674
 675   auto kernel = buildKernel<kernels::StridedSlice>(op);
 676   ASSERT_THAT(kernel, NotNull());
 677
 678   checkTensor(kernel->input(), input);
 679   checkTensor(kernel->begin(), begin);
 680   checkTensor(kernel->end(), end);
 681   checkTensor(kernel->strides(), strides);
 682   checkTensor(kernel->output(), op);
 683   EXPECT_THAT(kernel->params().begin_mask, Eq(op->begin_mask()));
 684   EXPECT_THAT(kernel->params().ellipsis_mask, Eq(op->ellipsis_mask()));
 685   EXPECT_THAT(kernel->params().end_mask, Eq(op->end_mask()));
 686   EXPECT_THAT(kernel->params().new_axis_mask, Eq(op->new_axis_mask()));
 687   EXPECT_THAT(kernel->params().shrink_axis_mask, Eq(op->shrink_axis_mask()));
 688 }
 689
 690 TEST_F(KernelBuilderTest, Tanh)
 691 {
 692   auto *input = createInputNode();
 693
 694   auto *op = createNode<luci::CircleTanh>();
 695   op->x(input);
 696
 697   auto kernel = buildKernel<kernels::Tanh>(op);
 698   ASSERT_THAT(kernel, NotNull());
 699
 700   checkTensor(kernel->input(), input);
 701   checkTensor(kernel->output(), op);
 702 }
 703
 704 TEST_F(KernelBuilderTest, Transpose)
 705 {
 706   auto *input = createInputNode();
 707   auto *perm = createInputNode();
 708
 709   auto *op = createNode<luci::CircleTranspose>();
 710   op->a(input);
 711   op->perm(perm);
 712
 713   auto kernel = buildKernel<kernels::Transpose>(op);
 714   ASSERT_THAT(kernel, NotNull());
 715
 716   checkTensor(kernel->input(), input);
 717   checkTensor(kernel->perm(), perm);
 718   checkTensor(kernel->output(), op);
 719 }
 720
 721 TEST_F(KernelBuilderTest, TransposeConv)
 722 {
 723   auto *output_shape = createInputNode();
 724   auto *filter = createInputNode();
 725   auto *input = createInputNode();
 726   auto *bias = createInputNode();
 727
 728   auto *op = createNode<luci::CircleTransposeConv>();
 729   op->inputSizes(output_shape);
 730   op->filter(filter);
 731   op->outBackprop(input);
 732   op->bias(bias);
 733
 734   op->padding(luci::Padding::SAME);
 735   op->stride()->h(11);
 736   op->stride()->w(13);
 737
 738   auto kernel = buildKernel<kernels::TransposeConv>(op);
 739   ASSERT_THAT(kernel, NotNull());
 740
 741   checkTensor(kernel->output_shape(), output_shape);
 742   checkTensor(kernel->filter(), filter);
 743   checkTensor(kernel->input(), input);
 744   checkTensor(kernel->output(), op);
 745   checkTensor(kernel->bias(), bias);
 746   EXPECT_THAT(kernel->params().padding, Eq(op->padding()));
 747   EXPECT_THAT(kernel->params().stride_height, Eq(op->stride()->h()));
 748   EXPECT_THAT(kernel->params().stride_width, Eq(op->stride()->w()));
 749 }
 750
 751 TEST_F(KernelBuilderTest, Unpack)
 752 {
 753   auto *input = createInputNode();
 754   auto *op = createNode<luci::CircleUnpack>();
 755   auto *output1 = createNodeOut<luci::CircleUnpackOut>(op, 0);
 756   auto *output2 = createNodeOut<luci::CircleUnpackOut>(op, 1);
 757
 758   op->value(input);
 759
 760   op->num(2);
 761   op->axis(11);
 762
 763   auto kernel = buildKernel<kernels::Unpack>(op);
 764   ASSERT_THAT(kernel, NotNull());
 765
 766   checkTensor(kernel->input(), input);
 767   checkTensor(kernel->output(0), output1);
 768   checkTensor(kernel->output(1), output2);
 769   EXPECT_THAT(kernel->params().axis, Eq(op->axis()));
 770 }
 771
 772 TEST_F(KernelBuilderTest, NonExisting1_NEG)
 773 {
 774   auto *op = createNode<luci::CircleConst>();
 775   ASSERT_ANY_THROW(buildKernel<Kernel>(op));
 776 }
 777
 778 TEST_F(KernelBuilderTest, NonExisting2_NEG)
 779 {
 780   auto *op = createNode<luci::CircleInput>();
 781   ASSERT_ANY_THROW(buildKernel<Kernel>(op));
 782 }
 783
 784 TEST_F(KernelBuilderTest, NonExisting3_NEG)
 785 {
 786   auto *op = createNode<luci::CircleOutput>();
 787   ASSERT_ANY_THROW(buildKernel<Kernel>(op));
 788 }
 789
 790 } // namespace
 791 } // namespace luci_interpreter