ngraph/test/eval.cpp

   1 //*****************************************************************************
   2 // Copyright 2017-2020 Intel Corporation
   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 <cmath>
  18 #include <cstddef>
  19 #include <string>
  20 #include <vector>
  21
  22 #include "gmock/gmock.h"
  23 #include "gtest/gtest.h"
  24
  25 #include "ngraph/node.hpp"
  26 #include "ngraph/node_output.hpp"
  27 #include "ngraph/op/abs.hpp"
  28 #include "ngraph/op/acos.hpp"
  29 #include "ngraph/op/add.hpp"
  30 #include "ngraph/op/asin.hpp"
  31 #include "ngraph/op/atan.hpp"
  32 #include "ngraph/op/broadcast.hpp"
  33 #include "ngraph/op/ceiling.hpp"
  34 #include "ngraph/op/concat.hpp"
  35 #include "ngraph/op/constant.hpp"
  36 #include "ngraph/op/convert.hpp"
  37 #include "ngraph/op/cos.hpp"
  38 #include "ngraph/op/cosh.hpp"
  39 #include "ngraph/op/erf.hpp"
  40 #include "ngraph/op/exp.hpp"
  41 #include "ngraph/op/floor.hpp"
  42 #include "ngraph/op/gather.hpp"
  43 #include "ngraph/op/log.hpp"
  44 #include "ngraph/op/max_pool.hpp"
  45 #include "ngraph/op/min.hpp"
  46 #include "ngraph/op/minimum.hpp"
  47 #include "ngraph/op/negative.hpp"
  48 #include "ngraph/op/non_zero.hpp"
  49 #include "ngraph/op/not.hpp"
  50 #include "ngraph/op/parameter.hpp"
  51 #include "ngraph/op/range.hpp"
  52 #include "ngraph/op/reduce_logical_and.hpp"
  53 #include "ngraph/op/relu.hpp"
  54 #include "ngraph/op/reshape.hpp"
  55 #include "ngraph/op/round.hpp"
  56 #include "ngraph/op/scatter_elements_update.hpp"
  57 #include "ngraph/op/shape_of.hpp"
  58 #include "ngraph/op/sigmoid.hpp"
  59 #include "ngraph/op/sign.hpp"
  60 #include "ngraph/op/sin.hpp"
  61 #include "ngraph/op/sinh.hpp"
  62 #include "ngraph/op/sqrt.hpp"
  63 #include "ngraph/op/squeeze.hpp"
  64 #include "ngraph/op/stop_gradient.hpp"
  65 #include "ngraph/op/tan.hpp"
  66 #include "ngraph/op/tanh.hpp"
  67 #include "ngraph/op/topk.hpp"
  68 #include "ngraph/op/transpose.hpp"
  69 #include "ngraph/op/unsqueeze.hpp"
  70 #include "ngraph/runtime/host_tensor.hpp"
  71 #include "ngraph/validation_util.hpp"
  72 #include "util/all_close_f.hpp"
  73 #include "util/ndarray.hpp"
  74 #include "util/test_tools.hpp"
  75 #include "util/type_prop.hpp"
  76
  77 NGRAPH_SUPPRESS_DEPRECATED_START
  78
  79 using namespace std;
  80 using namespace ngraph;
  81
  82 #define ASSERT_FLOAT_VECTORS_EQ(expected, result)                                                  \
  83     ASSERT_EQ(expected.size(), result.size()) << "Array sizes differ.";                            \
  84     for (size_t i = 0; i < expected.size(); ++i)                                                   \
  85     {                                                                                              \
  86         ASSERT_FLOAT_EQ(expected[i], result[i]) << "at index: " << i;                              \
  87     }
  88
  89 TEST(eval, bad_get_data_ptr)
  90 {
  91     HostTensor c(element::f32, Shape{});
  92     *c.get_data_ptr<float>() = 1.0;
  93     EXPECT_EQ(*c.get_data_ptr<element::Type_t::f32>(), 1.0);
  94     try
  95     {
  96         c.get_data_ptr<element::Type_t::f64>();
  97         FAIL() << "Bad type not detected.";
  98     }
  99     catch (const CheckFailure& error)
 100     {
 101         EXPECT_HAS_SUBSTRING(error.what(), std::string("get_data_ptr"));
 102     }
 103     try
 104     {
 105         c.get_data_ptr<element::Type_t::i32>();
 106         FAIL() << "Bad type not detected.";
 107     }
 108     catch (const CheckFailure& error)
 109     {
 110         EXPECT_HAS_SUBSTRING(error.what(), std::string("get_data_ptr"));
 111     }
 112 }
 113
 114 TEST(eval, max_eval_parameter)
 115 {
 116     auto p = make_shared<op::Parameter>(element::i64, Shape{});
 117
 118     auto result = maximum_value(p);
 119     EXPECT_FALSE(result.first);
 120     EXPECT_EQ(result.second, numeric_limits<uint64_t>::max());
 121 }
 122
 123 TEST(eval, max_eval_constant)
 124 {
 125     auto c = op::Constant::create<int64_t>(element::i64, Shape{}, {27});
 126     auto result = maximum_value(c);
 127     ASSERT_TRUE(result.first);
 128     EXPECT_EQ(result.second, 27);
 129 }
 130
 131 TEST(eval, max_eval_minimum_constant)
 132 {
 133     auto c = op::Constant::create<int64_t>(element::i64, Shape{}, {27});
 134     auto p = make_shared<op::Parameter>(element::i64, Shape{});
 135     auto m = make_shared<op::Minimum>(c, p);
 136     auto result = maximum_value(m);
 137     ASSERT_TRUE(result.first);
 138     EXPECT_EQ(result.second, 27);
 139 }
 140
 141 TEST(eval, max_eval_reduce_min)
 142 {
 143     auto concat = make_shared<op::v0::Convert>(
 144         make_shared<op::v0::Concat>(
 145             OutputVector{make_shared<op::v0::Parameter>(element::i64, Shape{4}),
 146                          make_shared<op::v0::Constant>(element::i64, Shape{4}, 37)},
 147             0),
 148         element::i32);
 149     auto reduce = make_shared<op::v0::Convert>(
 150         make_shared<op::v1::ReduceMin>(concat,
 151                                        make_shared<op::v0::Constant>(element::i32, Shape{1}, 0)),
 152         element::i64);
 153     auto squeezes = make_shared<op::v0::Squeeze>(
 154         make_shared<op::v0::Unsqueeze>(reduce,
 155                                        make_shared<op::v0::Constant>(element::i32, Shape{1}, 0)),
 156         make_shared<op::v0::Constant>(element::i64, Shape{1}, 0));
 157     EXPECT_EQ(maximum_value(squeezes).second, 37);
 158 }
 159
 160 TEST(eval, evaluate_shape_of)
 161 {
 162     auto p = make_shared<op::Parameter>(element::f32, PartialShape{-1, -1});
 163     auto so = make_shared<op::v0::ShapeOf>(p);
 164     auto fun = make_shared<Function>(OutputVector{so}, ParameterVector{p});
 165     auto result = make_shared<HostTensor>();
 166     ASSERT_TRUE(fun->evaluate({result},
 167                               {make_host_tensor<element::Type_t::f32>(
 168                                   Shape{2, 3}, {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f})}));
 169     EXPECT_EQ(result->get_element_type(), element::i64);
 170     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2}));
 171     auto result_shape = read_vector<int64_t>(result);
 172     vector<int64_t> arg_shape{2, 3};
 173     ASSERT_EQ(result_shape, arg_shape);
 174 }
 175
 176 TEST(eval, evaluate_dynamic_range_sum)
 177 {
 178     auto p_start = make_shared<op::Parameter>(element::f32, PartialShape{});
 179     auto p_stop = make_shared<op::Parameter>(element::f32, PartialShape{});
 180     auto p_step = make_shared<op::Parameter>(element::f32, PartialShape{});
 181     auto p1 = make_shared<op::Parameter>(element::f32, PartialShape{});
 182     auto range = make_shared<op::v0::Range>(p_start, p_stop, p_step);
 183     auto add = make_shared<op::v1::Add>(range, p1);
 184     auto fun =
 185         make_shared<Function>(OutputVector{add}, ParameterVector{p_start, p_stop, p_step, p1});
 186     auto result_tensor = make_shared<HostTensor>();
 187     ASSERT_TRUE(fun->evaluate({result_tensor},
 188                               {make_host_tensor<element::Type_t::f32>({}, {1.0f}),
 189                                make_host_tensor<element::Type_t::f32>({}, {10.0f}),
 190                                make_host_tensor<element::Type_t::f32>({}, {3.0f}),
 191                                make_host_tensor<element::Type_t::f32>({}, {7.0f})}));
 192     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
 193     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3}));
 194     auto cval = read_vector<float>(result_tensor);
 195     vector<float> seq{8.0f, 11.0f, 14.0f};
 196     ASSERT_EQ(cval, seq);
 197 }
 198
 199 #ifdef NGRAPH_INTERPRETER_ENABLE
 200 TEST(eval, interpret_dynamic_range_sum)
 201 {
 202     auto p_start = make_shared<op::Parameter>(element::f32, PartialShape{});
 203     auto p_stop = make_shared<op::Parameter>(element::f32, PartialShape{});
 204     auto p_step = make_shared<op::Parameter>(element::f32, PartialShape{});
 205     auto p1 = make_shared<op::Parameter>(element::f32, PartialShape{});
 206     auto range = make_shared<op::v0::Range>(p_start, p_stop, p_step);
 207     auto add = make_shared<op::v1::Add>(range, p1);
 208     auto fun =
 209         make_shared<Function>(OutputVector{add}, ParameterVector{p_start, p_stop, p_step, p1});
 210     auto backend = runtime::Backend::create("INTERPRETER");
 211     auto p_start_val = backend->create_tensor(element::f32, Shape{});
 212     copy_data(p_start_val, vector<float>{1.0f});
 213     auto p_stop_val = backend->create_tensor(element::f32, Shape{});
 214     copy_data(p_stop_val, vector<float>{10.0f});
 215     auto p_step_val = backend->create_tensor(element::f32, Shape{});
 216     copy_data(p_step_val, vector<float>{3.0f});
 217     auto p1_val = backend->create_tensor(element::f32, Shape{});
 218     copy_data(p1_val, vector<float>{7.0f});
 219     auto result = backend->create_tensor();
 220     auto cfun = backend->compile(fun);
 221     cfun->call({result}, {p_start_val, p_stop_val, p_step_val, p1_val});
 222     EXPECT_EQ(result->get_element_type(), element::f32);
 223     EXPECT_EQ(result->get_partial_shape(), (PartialShape{3}));
 224     auto result_val = read_vector<float>(result);
 225     vector<float> seq{8.0f, 11.0f, 14.0f};
 226     ASSERT_EQ(result_val, seq);
 227 }
 228 #endif
 229
 230 TEST(eval, evaluate_broadcast_v3_bidirectional)
 231 {
 232     Shape shape_a{4, 1};
 233     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 234     auto target_shape = op::Constant::create<int32_t>(element::i32, Shape{3}, {2, 1, 4});
 235     auto bcast_v3 =
 236         make_shared<op::v3::Broadcast>(A, target_shape, op::BroadcastType::BIDIRECTIONAL);
 237     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 238
 239     auto result = make_shared<HostTensor>();
 240     ASSERT_TRUE(fun->evaluate(
 241         {result}, {make_host_tensor<element::Type_t::f32>(Shape{4, 1}, {1.0f, 2.0f, 3.0f, 4.0f})}));
 242     EXPECT_EQ(result->get_element_type(), element::f32);
 243     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 4, 4}));
 244     auto result_val = read_vector<float>(result);
 245     vector<float> expec{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4,
 246                         1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
 247     ASSERT_EQ(result_val, expec);
 248 }
 249
 250 TEST(eval, evaluate_broadcast_v3_bidirectional_dyn)
 251 {
 252     Shape shape_a{4, 1};
 253     auto A = make_shared<op::Parameter>(element::i32, shape_a);
 254     auto target_shape = make_shared<op::Parameter>(element::i32, Shape{3});
 255     auto bcast_v3 =
 256         make_shared<op::v3::Broadcast>(A, target_shape, op::BroadcastType::BIDIRECTIONAL);
 257     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A, target_shape});
 258
 259     auto result = make_shared<HostTensor>();
 260     ASSERT_TRUE(fun->evaluate({result},
 261                               {make_host_tensor<element::Type_t::i32>(Shape{4, 1}, {1, 2, 3, 4}),
 262                                make_host_tensor<element::Type_t::i32>(Shape{3}, {2, 1, 4})}));
 263     EXPECT_EQ(result->get_element_type(), element::i32);
 264     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 4, 4}));
 265     auto result_val = read_vector<int32_t>(result);
 266     vector<int32_t> expec{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4,
 267                           1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
 268     ASSERT_EQ(result_val, expec);
 269 }
 270
 271 TEST(eval, evaluate_broadcast_v3_numpy)
 272 {
 273     Shape shape_a{3, 1};
 274     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 275     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 6});
 276     auto bcast_v3 = make_shared<op::v3::Broadcast>(A, target_shape);
 277     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 278
 279     auto result = make_shared<HostTensor>();
 280     ASSERT_TRUE(fun->evaluate(
 281         {result}, {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f})}));
 282     EXPECT_EQ(result->get_element_type(), element::f32);
 283     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 284     auto result_val = read_vector<float>(result);
 285     vector<float> expec{
 286         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 287         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 288     };
 289     ASSERT_EQ(result_val, expec);
 290 }
 291
 292 TEST(eval, evaluate_broadcast_v3_numpy_dyn)
 293 {
 294     Shape shape_a{3, 1};
 295     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 296     auto target_shape = make_shared<op::Parameter>(element::i32, Shape{3});
 297     auto bcast_v3 = make_shared<op::v3::Broadcast>(A, target_shape);
 298     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A, target_shape});
 299
 300     auto result = make_shared<HostTensor>();
 301     ASSERT_TRUE(
 302         fun->evaluate({result},
 303                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 304                        make_host_tensor<element::Type_t::i32>(Shape{3}, {2, 3, 6})}));
 305     EXPECT_EQ(result->get_element_type(), element::f32);
 306     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 307     auto result_val = read_vector<float>(result);
 308     vector<float> expec{
 309         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 310         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 311     };
 312     ASSERT_EQ(result_val, expec);
 313 }
 314
 315 TEST(eval, evaluate_broadcast_v3_numpy_vs_bidi)
 316 {
 317     Shape in_shape{1, 4, 1};
 318
 319     auto A = make_shared<op::Parameter>(element::f32, in_shape);
 320     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {1, 4, 4});
 321     auto bcast_v3_num = make_shared<op::v3::Broadcast>(A, target_shape, op::BroadcastType::NUMPY);
 322     auto fun_num = make_shared<Function>(OutputVector{bcast_v3_num}, ParameterVector{A});
 323
 324     auto result = make_shared<HostTensor>();
 325     ASSERT_TRUE(fun_num->evaluate(
 326         {result}, {make_host_tensor<element::Type_t::f32>(in_shape, {1.0f, 2.0f, 3.0f, 4.0f})}));
 327     EXPECT_EQ(result->get_element_type(), element::f32);
 328     EXPECT_EQ(result->get_partial_shape(), (PartialShape{1, 4, 4}));
 329     auto result_val = read_vector<float>(result);
 330     vector<float> expec{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
 331     ASSERT_EQ(expec, result_val);
 332
 333     auto target_shape2 = op::Constant::create<int64_t>(element::i64, Shape{2}, {1, 4});
 334     auto bcast_v3 =
 335         make_shared<op::v3::Broadcast>(A, target_shape2, op::BroadcastType::BIDIRECTIONAL);
 336     auto fun_bidi = make_shared<Function>(OutputVector{bcast_v3_num}, ParameterVector{A});
 337
 338     auto result2 = make_shared<HostTensor>();
 339     ASSERT_TRUE(fun_bidi->evaluate(
 340         {result2}, {make_host_tensor<element::Type_t::f32>(in_shape, {1.0f, 2.0f, 3.0f, 4.0f})}));
 341     EXPECT_EQ(result2->get_element_type(), element::f32);
 342     EXPECT_EQ(result2->get_partial_shape(), (PartialShape{1, 4, 4}));
 343     auto result_val2 = read_vector<float>(result2);
 344     vector<float> expec2{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
 345     ASSERT_EQ(expec2, result_val2);
 346 }
 347
 348 TEST(eval, evaluate_broadcast_v3_bidi_3d)
 349 {
 350     Shape in_shape{1, 4, 1};
 351
 352     auto A = make_shared<op::Parameter>(element::f32, in_shape);
 353     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {1, 1, 3});
 354     auto bcast_v3_num =
 355         make_shared<op::v3::Broadcast>(A, target_shape, op::BroadcastType::BIDIRECTIONAL);
 356     auto fun_num = make_shared<Function>(OutputVector{bcast_v3_num}, ParameterVector{A});
 357
 358     auto result = make_shared<HostTensor>();
 359     ASSERT_TRUE(fun_num->evaluate(
 360         {result}, {make_host_tensor<element::Type_t::f32>(in_shape, {1.0f, 2.0f, 3.0f, 4.0f})}));
 361     EXPECT_EQ(result->get_element_type(), element::f32);
 362     EXPECT_EQ(result->get_partial_shape(), (PartialShape{1, 4, 3}));
 363     auto result_val = read_vector<float>(result);
 364     vector<float> expec{1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f, 3.0f, 3.0f, 3.0f, 4.0f, 4.0f, 4.0f};
 365     ASSERT_EQ(expec, result_val);
 366 }
 367
 368 TEST(eval, evaluate_broadcast_v3_bidi_4d)
 369 {
 370     Shape in_shape{4, 1, 1};
 371     Shape expec_shape{1, 4, 2, 2};
 372
 373     auto A = make_shared<op::Parameter>(element::f32, in_shape);
 374     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{4}, {1, 1, 2, 2});
 375     auto bcast_v3 =
 376         make_shared<op::v3::Broadcast>(A, target_shape, op::BroadcastType::BIDIRECTIONAL);
 377     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 378
 379     auto result = make_shared<HostTensor>();
 380     ASSERT_TRUE(fun->evaluate(
 381         {result}, {make_host_tensor<element::Type_t::f32>(in_shape, {1.0f, 2.0f, 3.0f, 4.0f})}));
 382     EXPECT_EQ(result->get_element_type(), element::f32);
 383     EXPECT_EQ(result->get_partial_shape(), (PartialShape{1, 4, 2, 2}));
 384     auto result_val = read_vector<float>(result);
 385     vector<float> expec{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4};
 386     ASSERT_EQ(result_val, expec);
 387 }
 388
 389 TEST(eval, evaluate_broadcast_v3_pdpd)
 390 {
 391     Shape shape_a{3, 1};
 392     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 393     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 6});
 394     auto bcast_v3 = make_shared<op::v3::Broadcast>(
 395         A, target_shape, op::BroadcastModeSpec(op::BroadcastType::PDPD, 1));
 396     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 397
 398     auto result = make_shared<HostTensor>();
 399     ASSERT_TRUE(fun->evaluate(
 400         {result}, {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f})}));
 401     EXPECT_EQ(result->get_element_type(), element::f32);
 402     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 403     auto result_val = read_vector<float>(result);
 404     vector<float> expec{
 405         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 406         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 407     };
 408     ASSERT_EQ(result_val, expec);
 409 }
 410
 411 TEST(eval, evaluate_broadcast_v3_pdpd_dyn)
 412 {
 413     Shape shape_a{3, 1};
 414     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 415     auto target_shape = make_shared<op::Parameter>(element::i32, Shape{3});
 416     auto bcast_v3 = make_shared<op::v3::Broadcast>(
 417         A, target_shape, op::BroadcastModeSpec(op::BroadcastType::PDPD, 1));
 418     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A, target_shape});
 419
 420     auto result = make_shared<HostTensor>();
 421     ASSERT_TRUE(
 422         fun->evaluate({result},
 423                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 424                        make_host_tensor<element::Type_t::i32>(Shape{3}, {2, 3, 6})}));
 425     EXPECT_EQ(result->get_element_type(), element::f32);
 426     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 427     auto result_val = read_vector<float>(result);
 428     vector<float> expec{
 429         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 430         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 431     };
 432     ASSERT_EQ(result_val, expec);
 433 }
 434
 435 TEST(eval, evaluate_broadcast_v1_numpy)
 436 {
 437     Shape shape_a{3, 1};
 438     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 439     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 6});
 440     auto bcast_v3 = make_shared<op::v1::Broadcast>(A, target_shape);
 441     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 442
 443     auto result = make_shared<HostTensor>();
 444     ASSERT_TRUE(fun->evaluate(
 445         {result}, {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f})}));
 446     EXPECT_EQ(result->get_element_type(), element::f32);
 447     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 448     auto result_val = read_vector<float>(result);
 449     vector<float> expec{
 450         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 451         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 452     };
 453     ASSERT_EQ(result_val, expec);
 454 }
 455
 456 TEST(eval, evaluate_broadcast_v1_numpy_dyn)
 457 {
 458     Shape shape_a{3, 1};
 459     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 460     auto target_shape = make_shared<op::Parameter>(element::i64, Shape{3});
 461     auto bcast_v3 = make_shared<op::v1::Broadcast>(A, target_shape);
 462     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A, target_shape});
 463
 464     auto result = make_shared<HostTensor>();
 465     ASSERT_TRUE(
 466         fun->evaluate({result},
 467                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 468                        make_host_tensor<element::Type_t::i64>(Shape{3}, {2, 3, 6})}));
 469     EXPECT_EQ(result->get_element_type(), element::f32);
 470     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 471     auto result_val = read_vector<float>(result);
 472     vector<float> expec{
 473         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 474         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 475     };
 476     ASSERT_EQ(result_val, expec);
 477 }
 478
 479 TEST(eval, evaluate_broadcast_v1_pdpd)
 480 {
 481     Shape shape_a{3, 1};
 482     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 483     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 6});
 484     auto bcast_v3 = make_shared<op::v1::Broadcast>(
 485         A, target_shape, op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, 1));
 486     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 487
 488     auto result = make_shared<HostTensor>();
 489     ASSERT_TRUE(fun->evaluate(
 490         {result}, {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f})}));
 491     EXPECT_EQ(result->get_element_type(), element::f32);
 492     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 493     auto result_val = read_vector<float>(result);
 494     vector<float> expec{
 495         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 496         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 497     };
 498     ASSERT_EQ(result_val, expec);
 499 }
 500
 501 TEST(eval, evaluate_broadcast_v1_pdpd_dyn)
 502 {
 503     Shape shape_a{3, 1};
 504     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 505     auto target_shape = make_shared<op::Parameter>(element::i64, Shape{3});
 506     auto bcast_v3 = make_shared<op::v1::Broadcast>(
 507         A, target_shape, op::AutoBroadcastSpec(op::AutoBroadcastType::PDPD, 1));
 508     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A, target_shape});
 509
 510     auto result = make_shared<HostTensor>();
 511     ASSERT_TRUE(
 512         fun->evaluate({result},
 513                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 514                        make_host_tensor<element::Type_t::i64>(Shape{3}, {2, 3, 6})}));
 515     EXPECT_EQ(result->get_element_type(), element::f32);
 516     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 6}));
 517     auto result_val = read_vector<float>(result);
 518     vector<float> expec{
 519         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 520         1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
 521     };
 522     ASSERT_EQ(result_val, expec);
 523 }
 524
 525 TEST(eval, evaluate_broadcast_v1_explicit)
 526 {
 527     Shape shape_a{3, 1};
 528     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 529     auto target_shape = op::Constant::create<int64_t>(element::i64, Shape{3}, {2, 3, 1});
 530     auto axes_mapping = op::Constant::create<int32_t>(element::i32, Shape{2}, {1, 2});
 531     auto bcast_v3 = make_shared<op::v1::Broadcast>(
 532         A, target_shape, axes_mapping, op::AutoBroadcastSpec(op::AutoBroadcastType::EXPLICIT));
 533     auto fun = make_shared<Function>(OutputVector{bcast_v3}, ParameterVector{A});
 534
 535     auto result = make_shared<HostTensor>();
 536     ASSERT_TRUE(fun->evaluate(
 537         {result}, {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f})}));
 538     EXPECT_EQ(result->get_element_type(), element::f32);
 539     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 1}));
 540     auto result_val = read_vector<float>(result);
 541     vector<float> expec{1, 2, 3, 1, 2, 3};
 542     ASSERT_EQ(result_val, expec);
 543 }
 544
 545 TEST(eval, evaluate_broadcast_v1_explicit_dyn)
 546 {
 547     Shape shape_a{3, 1};
 548     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 549     auto target_shape = make_shared<op::Parameter>(element::i64, Shape{3});
 550     auto axes_mapping = make_shared<op::Parameter>(element::i32, Shape{2});
 551
 552     auto bcast_v1 = make_shared<op::v1::Broadcast>(
 553         A, target_shape, axes_mapping, op::AutoBroadcastSpec(op::AutoBroadcastType::EXPLICIT));
 554     auto fun = make_shared<Function>(OutputVector{bcast_v1},
 555                                      ParameterVector{A, target_shape, axes_mapping});
 556
 557     auto result = make_shared<HostTensor>();
 558     ASSERT_TRUE(
 559         fun->evaluate({result},
 560                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 561                        make_host_tensor<element::Type_t::i64>(Shape{3}, {2, 3, 1}),
 562                        make_host_tensor<element::Type_t::i32>(Shape{2}, {1, 2})}));
 563     EXPECT_EQ(result->get_element_type(), element::f32);
 564     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 1}));
 565     auto result_val = read_vector<float>(result);
 566     vector<float> expec{1, 2, 3, 1, 2, 3};
 567     ASSERT_EQ(result_val, expec);
 568 }
 569
 570 TEST(eval, evaluate_broadcast_v3_explicit_dyn)
 571 {
 572     Shape shape_a{3, 1};
 573     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 574     auto target_shape = make_shared<op::Parameter>(element::i64, Shape{3});
 575     auto axes_mapping = make_shared<op::Parameter>(element::i32, Shape{2});
 576
 577     auto bcast_v3 = make_shared<op::v3::Broadcast>(
 578         A, target_shape, axes_mapping, op::BroadcastModeSpec(op::BroadcastType::EXPLICIT));
 579     auto fun = make_shared<Function>(OutputVector{bcast_v3},
 580                                      ParameterVector{A, target_shape, axes_mapping});
 581
 582     auto result = make_shared<HostTensor>();
 583     ASSERT_TRUE(
 584         fun->evaluate({result},
 585                       {make_host_tensor<element::Type_t::f32>(Shape{3, 1}, {1.0f, 2.0f, 3.0f}),
 586                        make_host_tensor<element::Type_t::i64>(Shape{3}, {2, 3, 1}),
 587                        make_host_tensor<element::Type_t::i32>(Shape{2}, {1, 2})}));
 588     EXPECT_EQ(result->get_element_type(), element::f32);
 589     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 1}));
 590     auto result_val = read_vector<float>(result);
 591     vector<float> expec{1, 2, 3, 1, 2, 3};
 592     ASSERT_EQ(result_val, expec);
 593 }
 594
 595 TEST(eval, evaluate_broadcast_v0)
 596 {
 597     Shape shape_a{2, 4};
 598     auto A = make_shared<op::Parameter>(element::f32, shape_a);
 599     Shape target_shape = Shape{2, 3, 4};
 600     auto bcast_v0 = make_shared<op::v0::Broadcast>(A, target_shape, AxisSet{1});
 601     auto fun = make_shared<Function>(OutputVector{bcast_v0}, ParameterVector{A});
 602
 603     auto result = make_shared<HostTensor>();
 604     ASSERT_TRUE(fun->evaluate(
 605         {result}, {make_host_tensor<element::Type_t::f32>(Shape{2, 4}, {1, 2, 3, 4, 1, 2, 3, 4})}));
 606     EXPECT_EQ(result->get_element_type(), element::f32);
 607     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3, 4}));
 608     auto result_val = read_vector<float>(result);
 609     vector<float> expec{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4};
 610     ASSERT_EQ(result_val, expec);
 611 }
 612
 613 TEST(eval, test_op_multi_out)
 614 {
 615     auto p = make_shared<op::Parameter>(element::f32, PartialShape{2, 3});
 616     auto p2 = make_shared<op::Parameter>(element::f64, PartialShape{2, 2});
 617     auto so = make_shared<TestOpMultiOut>(p, p2);
 618     auto fun =
 619         make_shared<Function>(OutputVector{so->output(0), so->output(1)}, ParameterVector{p, p2});
 620     auto result = make_shared<HostTensor>(element::Type_t::f32, Shape{2, 3});
 621     auto result2 = make_shared<HostTensor>(element::Type_t::f64, Shape{2, 2});
 622     HostTensorVector ins{make_host_tensor<element::Type_t::f32>(Shape{2, 3}),
 623                          make_host_tensor<element::Type_t::f64>(Shape{2, 2})};
 624     ASSERT_TRUE(fun->evaluate({result, result2}, ins));
 625     EXPECT_EQ(result->get_element_type(), element::f32);
 626     EXPECT_EQ(result->get_partial_shape(), (PartialShape{2, 3}));
 627     auto result_val = read_vector<float>(result);
 628     auto arg_val = read_vector<float>(ins[0]);
 629     ASSERT_EQ(result_val, arg_val);
 630     EXPECT_EQ(result2->get_element_type(), element::f64);
 631     EXPECT_EQ(result2->get_partial_shape(), (PartialShape{2, 2}));
 632     auto result_val2 = read_vector<double>(result2);
 633     auto arg_val2 = read_vector<double>(ins[1]);
 634     ASSERT_EQ(result_val2, arg_val2);
 635 }
 636
 637 TEST(eval, evaluate_reshape_v1)
 638 {
 639     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 640     auto pattern = make_shared<op::Parameter>(element::i64, Shape{2});
 641     auto dyn_reshape = make_shared<op::v1::Reshape>(data, pattern, false);
 642     auto func = make_shared<Function>(OutputVector{dyn_reshape}, ParameterVector{data, pattern});
 643     auto result_tensor = make_shared<HostTensor>();
 644     ASSERT_TRUE(func->evaluate(
 645         {result_tensor},
 646         {make_host_tensor<element::Type_t::f32>({2, 5}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
 647          make_host_tensor<element::Type_t::i64>({2}, {5, 2})}));
 648     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
 649     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{5, 2}));
 650     auto computed_val = read_vector<float>(result_tensor);
 651     vector<float> expected_val{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 652     ASSERT_EQ(computed_val, expected_val);
 653 }
 654
 655 TEST(eval, evaluate_reshape_v1_negative_index)
 656 {
 657     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 658     auto pattern = make_shared<op::Parameter>(element::i64, Shape{2});
 659     auto dyn_reshape = make_shared<op::v1::Reshape>(data, pattern, false);
 660     auto func = make_shared<Function>(OutputVector{dyn_reshape}, ParameterVector{data, pattern});
 661     auto result_tensor = make_shared<HostTensor>();
 662     ASSERT_TRUE(func->evaluate(
 663         {result_tensor},
 664         {make_host_tensor<element::Type_t::f32>({2, 5}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
 665          make_host_tensor<element::Type_t::i64>({2}, {2, -1})}));
 666     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
 667     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{2, 5}));
 668     auto computed_val = read_vector<float>(result_tensor);
 669     vector<float> expected_val{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 670     ASSERT_EQ(computed_val, expected_val);
 671 }
 672
 673 TEST(eval, evaluate_reshape_v1_negative_index_zero_dim_zero_flag)
 674 {
 675     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 2, 2, 2});
 676     auto pattern = make_shared<op::Parameter>(element::i64, Shape{6});
 677     auto dyn_reshape = make_shared<op::v1::Reshape>(data, pattern, true);
 678     auto func = make_shared<Function>(OutputVector{dyn_reshape}, ParameterVector{data, pattern});
 679     auto result_tensor = make_shared<HostTensor>();
 680     ASSERT_TRUE(
 681         func->evaluate({result_tensor},
 682                        {make_host_tensor<element::Type_t::f32>(
 683                             {2, 2, 2, 2}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
 684                         make_host_tensor<element::Type_t::i64>({6}, {2, 0, 1, -1, 1, 2})}));
 685     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
 686     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{2, 2, 1, 2, 1, 2}));
 687     auto computed_val = read_vector<float>(result_tensor);
 688     vector<float> expected_val{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
 689     ASSERT_EQ(computed_val, expected_val);
 690 }
 691
 692 TEST(eval, evaluate_reshape_v1_pattern_int16)
 693 {
 694     auto data = make_shared<op::Parameter>(element::f32, Shape{2, 2, 2, 2});
 695     auto pattern = make_shared<op::Parameter>(element::i16, Shape{6});
 696     auto dyn_reshape = make_shared<op::v1::Reshape>(data, pattern, true);
 697     auto func = make_shared<Function>(OutputVector{dyn_reshape}, ParameterVector{data, pattern});
 698     auto result_tensor = make_shared<HostTensor>();
 699     ASSERT_TRUE(
 700         func->evaluate({result_tensor},
 701                        {make_host_tensor<element::Type_t::f32>(
 702                             {2, 2, 2, 2}, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}),
 703                         make_host_tensor<element::Type_t::i16>({6}, {2, 0, 1, -1, 1, 2})}));
 704     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
 705     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{2, 2, 1, 2, 1, 2}));
 706     auto computed_val = read_vector<float>(result_tensor);
 707     vector<float> expected_val{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
 708     ASSERT_EQ(computed_val, expected_val);
 709 }
 710
 711 TEST(eval, evaluate_convert)
 712 {
 713     auto p = make_shared<op::Parameter>(element::f32, PartialShape{-1, -1});
 714     auto convert = make_shared<op::v0::Convert>(p, element::i64);
 715     auto fun = make_shared<Function>(OutputVector{convert}, ParameterVector{p});
 716
 717     std::vector<std::vector<float>> inputs{{-1, 1}};
 718     std::vector<std::vector<int64_t>> expected_result{{-1, 1}};
 719     for (size_t i = 0; i < inputs.size(); i++)
 720     {
 721         auto result = make_shared<HostTensor>();
 722         ASSERT_TRUE(fun->evaluate(
 723             {result}, {make_host_tensor<element::Type_t::f32>(Shape{1, 2}, inputs[i])}));
 724         EXPECT_EQ(result->get_element_type(), element::i64);
 725         EXPECT_EQ(result->get_shape(), (Shape{1, 2}));
 726         auto result_data = read_vector<int64_t>(result);
 727         ASSERT_EQ(result_data, expected_result[i]);
 728     }
 729 }
 730
 731 TEST(eval, evaluate_abs)
 732 {
 733     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 3});
 734     auto abs = make_shared<op::Abs>(p);
 735     auto fun = make_shared<Function>(OutputVector{abs}, ParameterVector{p});
 736     auto result = make_shared<HostTensor>();
 737     ASSERT_TRUE(fun->evaluate({result},
 738                               {make_host_tensor<element::Type_t::f32>(
 739                                   Shape{2, 3}, {0.0f, -1.0f, -2.0f, -3.0f, 4.0f, 5.0f})}));
 740     EXPECT_EQ(result->get_element_type(), element::f32);
 741     auto result_val = read_vector<float>(result);
 742     vector<float> expec{0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
 743     ASSERT_EQ(result_val, expec);
 744 }
 745
 746 TEST(eval, evaluate_erf)
 747 {
 748     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 3});
 749     auto erf = make_shared<op::Erf>(p);
 750     auto fun = make_shared<Function>(OutputVector{erf}, ParameterVector{p});
 751     auto result = make_shared<HostTensor>();
 752     ASSERT_TRUE(fun->evaluate({result},
 753                               {make_host_tensor<element::Type_t::f32>(
 754                                   Shape{2, 3}, {0.0f, -1.0f, -2.0f, -3.0f, 4.0f, 5.0f})}));
 755     EXPECT_EQ(result->get_element_type(), element::f32);
 756     auto result_val = read_vector<float>(result);
 757     vector<float> expec{std::erf(0.0f),
 758                         std::erf(-1.0f),
 759                         std::erf(-2.0f),
 760                         std::erf(-3.0f),
 761                         std::erf(4.0f),
 762                         std::erf(5.0f)};
 763     ASSERT_EQ(result_val, expec);
 764 }
 765
 766 TEST(eval, evaluate_exp)
 767 {
 768     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 3});
 769     auto exp = make_shared<op::Exp>(p);
 770     auto fun = make_shared<Function>(OutputVector{exp}, ParameterVector{p});
 771     auto result = make_shared<HostTensor>();
 772     ASSERT_TRUE(fun->evaluate({result},
 773                               {make_host_tensor<element::Type_t::f32>(
 774                                   Shape{2, 3}, {0.0f, -1.0f, -2.0f, -3.0f, 4.0f, 5.0f})}));
 775     EXPECT_EQ(result->get_element_type(), element::f32);
 776     auto result_val = read_vector<float>(result);
 777     vector<float> expec{std::exp(0.0f),
 778                         std::exp(-1.0f),
 779                         std::exp(-2.0f),
 780                         std::exp(-3.0f),
 781                         std::exp(4.0f),
 782                         std::exp(5.0f)};
 783     ASSERT_FLOAT_VECTORS_EQ(expec, result_val);
 784 }
 785
 786 TEST(eval, evaluate_floor)
 787 {
 788     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 2});
 789     auto floor = make_shared<op::Floor>(p);
 790     auto fun = make_shared<Function>(OutputVector{floor}, ParameterVector{p});
 791     auto result = make_shared<HostTensor>();
 792     ASSERT_TRUE(fun->evaluate(
 793         {result},
 794         {make_host_tensor<element::Type_t::f32>(Shape{2, 2}, {-2.5f, -2.0f, 0.3f, 4.8f})}));
 795     EXPECT_EQ(result->get_element_type(), element::f32);
 796     auto result_val = read_vector<float>(result);
 797     vector<float> expec{-3.0f, -2.0f, 0.0f, 4.0f};
 798     ASSERT_EQ(result_val, expec);
 799 }
 800
 801 TEST(eval, evaluate_floor_int32)
 802 {
 803     auto p = make_shared<op::Parameter>(element::i32, Shape{2, 2});
 804     auto floor = make_shared<op::Floor>(p);
 805     auto fun = make_shared<Function>(OutputVector{floor}, ParameterVector{p});
 806     auto result = make_shared<HostTensor>();
 807     ASSERT_TRUE(fun->evaluate({result},
 808                               {make_host_tensor<element::Type_t::i32>(
 809                                   Shape{2, 2}, {-2, -136314888, 0x40000010, 0x40000001})}));
 810     EXPECT_EQ(result->get_element_type(), element::i32);
 811     auto result_val = read_vector<int32_t>(result);
 812     vector<int32_t> expec{-2, -136314888, 0x40000010, 0x40000001};
 813     ASSERT_EQ(result_val, expec);
 814 }
 815
 816 TEST(eval, evaluate_log)
 817 {
 818     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 2, 2});
 819     auto log = make_shared<op::Log>(p);
 820     auto fun = make_shared<Function>(OutputVector{log}, ParameterVector{p});
 821     auto result = make_shared<HostTensor>();
 822     ASSERT_TRUE(
 823         fun->evaluate({result},
 824                       {make_host_tensor<element::Type_t::f32>(
 825                           Shape{2, 2, 2}, {0.125f, 0.25f, 0.5f, 1.f, 2.f, 4.f, 8.f, 16.f})}));
 826     EXPECT_EQ(result->get_element_type(), element::f32);
 827     auto result_val = read_vector<float>(result);
 828     vector<float> expec{std::log(0.125f),
 829                         std::log(0.25f),
 830                         std::log(0.5f),
 831                         std::log(1.f),
 832                         std::log(2.f),
 833                         std::log(4.f),
 834                         std::log(8.f),
 835                         std::log(16.f)};
 836     ASSERT_EQ(result_val, expec);
 837 }
 838
 839 TEST(eval, evaluate_negative_f32)
 840 {
 841     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 842     auto negate = make_shared<op::Negative>(p);
 843     auto fun = make_shared<Function>(OutputVector{negate}, ParameterVector{p});
 844     auto result = make_shared<HostTensor>();
 845     ASSERT_TRUE(fun->evaluate(
 846         {result},
 847         {make_host_tensor<element::Type_t::f32>(
 848             Shape{2, 5},
 849             {1.35f, 8.76f, -8.0f, 17.234f, -2.121f, 1.0f, 8.7f, -8.92f, 17.0f, -1.0f})}));
 850     EXPECT_EQ(result->get_element_type(), element::f32);
 851     auto result_val = read_vector<float>(result);
 852     vector<float> expec{-1.35f, -8.76f, 8.0f, -17.234f, 2.121f, -1.0f, -8.7f, 8.92f, -17.0f, 1.0f};
 853     ASSERT_EQ(result_val, expec);
 854 }
 855
 856 TEST(eval, evaluate_negative_i32)
 857 {
 858     auto p = make_shared<op::Parameter>(element::i32, Shape{2, 5});
 859     auto negate = make_shared<op::Negative>(p);
 860     auto fun = make_shared<Function>(OutputVector{negate}, ParameterVector{p});
 861     auto result = make_shared<HostTensor>();
 862     ASSERT_TRUE(fun->evaluate({result},
 863                               {make_host_tensor<element::Type_t::i32>(
 864                                   Shape{2, 5}, {1, 8, -8, 17, -2, 1, 8, -8, 17, 0})}));
 865     EXPECT_EQ(result->get_element_type(), element::i32);
 866     auto result_val = read_vector<int32_t>(result);
 867     vector<int32_t> expec{-1, -8, 8, -17, 2, -1, -8, 8, -17, 0};
 868     ASSERT_EQ(result_val, expec);
 869 }
 870
 871 TEST(eval, evaluate_relu_2Ffprop_f32)
 872 {
 873     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 5});
 874     auto relu = make_shared<op::Relu>(p);
 875     auto fun = make_shared<Function>(OutputVector{relu}, ParameterVector{p});
 876     auto result = make_shared<HostTensor>();
 877     ASSERT_TRUE(fun->evaluate({result},
 878                               {make_host_tensor<element::Type_t::f32>(
 879                                   Shape{2, 5}, {1, 8, -8, 17, -0.5, 0.1, 8.5, -8, 17, -0.5})}));
 880     EXPECT_EQ(result->get_element_type(), element::f32);
 881     auto result_val = read_vector<float>(result);
 882     vector<float> expec{1, 8, 0, 17, 0, 0.1, 8.5, 0, 17, 0};
 883     ASSERT_EQ(result_val, expec);
 884 }
 885
 886 TEST(eval, evaluate_relu_2Ffprop_i32)
 887 {
 888     auto p = make_shared<op::Parameter>(element::i32, Shape{2, 5});
 889     auto relu = make_shared<op::Relu>(p);
 890     auto fun = make_shared<Function>(OutputVector{relu}, ParameterVector{p});
 891     auto result = make_shared<HostTensor>();
 892     ASSERT_TRUE(fun->evaluate({result},
 893                               {make_host_tensor<element::Type_t::i32>(
 894                                   Shape{2, 5}, {1, 8, -8, 17, -2, 1, 8, -8, 17, -1})}));
 895     EXPECT_EQ(result->get_element_type(), element::i32);
 896     auto result_val = read_vector<int32_t>(result);
 897     vector<int32_t> expec{1, 8, 0, 17, 0, 1, 8, 0, 17, 0};
 898     ASSERT_EQ(result_val, expec);
 899 }
 900
 901 TEST(eval, evaluate_round)
 902 {
 903     auto p = make_shared<op::Parameter>(element::f32, Shape{5});
 904     auto round = make_shared<op::Round>(p);
 905     auto fun = make_shared<Function>(OutputVector{round}, ParameterVector{p});
 906     auto result = make_shared<HostTensor>();
 907     ASSERT_TRUE(fun->evaluate(
 908         {result},
 909         {make_host_tensor<element::Type_t::f32>(Shape{5}, {0.9f, 2.5f, 2.3f, 1.5f, -4.5f})}));
 910     EXPECT_EQ(result->get_element_type(), element::f32);
 911     auto result_val = read_vector<float>(result);
 912     vector<float> expec{1.0f, 2.0f, 2.0f, 2.0f, -4.0f};
 913     ASSERT_EQ(result_val, expec);
 914 }
 915
 916 TEST(eval, evaluate_round_2D)
 917 {
 918     auto p = make_shared<op::Parameter>(element::f32, Shape{3, 5});
 919     auto round = make_shared<op::Round>(p);
 920     auto fun = make_shared<Function>(OutputVector{round}, ParameterVector{p});
 921     auto result = make_shared<HostTensor>();
 922     ASSERT_TRUE(fun->evaluate({result},
 923                               {make_host_tensor<element::Type_t::f32>(Shape{3, 5},
 924                                                                       {0.1f,
 925                                                                        0.5f,
 926                                                                        0.9f,
 927                                                                        1.2f,
 928                                                                        1.5f,
 929                                                                        1.8f,
 930                                                                        2.3f,
 931                                                                        2.5f,
 932                                                                        2.7f,
 933                                                                        -1.1f,
 934                                                                        -1.5f,
 935                                                                        -1.9f,
 936                                                                        -2.2f,
 937                                                                        -2.5f,
 938                                                                        -2.8f})}));
 939     EXPECT_EQ(result->get_element_type(), element::f32);
 940     auto result_val = read_vector<float>(result);
 941     vector<float> expec{
 942         0.f, 0.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f, 3.f, -1.f, -2.f, -2.f, -2.f, -2.f, -3.f};
 943     ASSERT_EQ(result_val, expec);
 944 }
 945
 946 TEST(eval, evaluate_sigmoid)
 947 {
 948     auto p = make_shared<op::Parameter>(element::f32, Shape{1, 1, 2, 2});
 949     auto sigmoid = make_shared<op::Sigmoid>(p);
 950     auto fun = make_shared<Function>(OutputVector{sigmoid}, ParameterVector{p});
 951     auto result = make_shared<HostTensor>();
 952
 953     float x1 = 1.0f;
 954     float x2 = 4.0f;
 955     float sigma1 = 1.0f / (1.0f + std::exp(-x1));
 956     float sigma2 = 1.0f / (1.0f + std::exp(-x2));
 957     ASSERT_TRUE(fun->evaluate(
 958         {result}, {make_host_tensor<element::Type_t::f32>(Shape{1, 1, 2, 2}, {x1, x2, x1, x2})}));
 959     EXPECT_EQ(result->get_element_type(), element::f32);
 960     auto result_val = read_vector<float>(result);
 961     vector<float> expec{sigma1, sigma2, sigma1, sigma2};
 962     EXPECT_EQ(result_val.size(), expec.size());
 963 }
 964
 965 TEST(eval, evaluate_sign)
 966 {
 967     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 3});
 968     auto sign = make_shared<op::Sign>(p);
 969     auto fun = make_shared<Function>(OutputVector{sign}, ParameterVector{p});
 970     auto result = make_shared<HostTensor>();
 971
 972     ASSERT_TRUE(fun->evaluate(
 973         {result},
 974         {make_host_tensor<element::Type_t::f32>(Shape{2, 3}, {1, -2, 0, -4.8f, 4.8f, -0.0f})}));
 975     EXPECT_EQ(result->get_element_type(), element::f32);
 976     auto result_val = read_vector<float>(result);
 977     vector<float> expec{1, -1, 0, -1, 1, 0};
 978     ASSERT_EQ(result_val, expec);
 979 }
 980
 981 TEST(eval, evaluate_sin)
 982 {
 983     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
 984     auto sin = make_shared<op::Sin>(p);
 985     auto fun = make_shared<Function>(OutputVector{sin}, ParameterVector{p});
 986     auto result = make_shared<HostTensor>();
 987
 988     ASSERT_TRUE(fun->evaluate(
 989         {result},
 990         {make_host_tensor<element::Type_t::f32>(
 991             Shape{11}, {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f})}));
 992     EXPECT_EQ(result->get_element_type(), element::f32);
 993     auto result_val = read_vector<float>(result);
 994     vector<float> expec{0.00000000f,
 995                         0.24740396f,
 996                         -0.24740396f,
 997                         0.47942554f,
 998                         -0.47942554f,
 999                         0.84147098f,
1000                         -0.84147098f,
1001                         0.90929743f,
1002                         -0.90929743f,
1003                         -0.75680250f,
1004                         0.75680250f};
1005     ASSERT_FLOAT_VECTORS_EQ(expec, result_val);
1006 }
1007
1008 TEST(eval, evaluate_sinh)
1009 {
1010     auto p = make_shared<op::Parameter>(element::f32, Shape{6});
1011     auto sinh = make_shared<op::Sinh>(p);
1012     auto fun = make_shared<Function>(OutputVector{sinh}, ParameterVector{p});
1013     auto result = make_shared<HostTensor>();
1014
1015     vector<float> input{1.0f, 0.0f, -0.0f, -1.0f, 5.0f, -5.0f};
1016     ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{6}, input)}));
1017     EXPECT_EQ(result->get_element_type(), element::f32);
1018     auto result_val = read_vector<float>(result);
1019     std::transform(
1020         input.begin(), input.end(), input.begin(), [](float x) -> float { return sinhf(x); });
1021     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1022 }
1023
1024 TEST(eval, evaluate_sqrt)
1025 {
1026     auto p = make_shared<op::Parameter>(element::f32, Shape{6});
1027     auto sqrt = make_shared<op::Sqrt>(p);
1028     auto fun = make_shared<Function>(OutputVector{sqrt}, ParameterVector{p});
1029     auto result = make_shared<HostTensor>();
1030
1031     vector<float> input{16, 4, 81, 100, 10000, 0};
1032     ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{6}, input)}));
1033     EXPECT_EQ(result->get_element_type(), element::f32);
1034     auto result_val = read_vector<float>(result);
1035     vector<float> expec{4, 2, 9, 10, 100, 0};
1036     ASSERT_FLOAT_VECTORS_EQ(expec, result_val);
1037 }
1038
1039 TEST(eval, evaluate_acos)
1040 {
1041     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
1042     auto acos = make_shared<op::Acos>(p);
1043     auto fun = make_shared<Function>(OutputVector{acos}, ParameterVector{p});
1044     auto result = make_shared<HostTensor>();
1045
1046     vector<float> input{-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f};
1047     ASSERT_TRUE(
1048         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{11}, input)}));
1049     EXPECT_EQ(result->get_element_type(), element::f32);
1050     auto result_val = read_vector<float>(result);
1051     std::transform(
1052         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::acos(x); });
1053     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1054 }
1055
1056 TEST(eval, evaluate_asin)
1057 {
1058     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
1059     auto asin = make_shared<op::Asin>(p);
1060     auto fun = make_shared<Function>(OutputVector{asin}, ParameterVector{p});
1061     auto result = make_shared<HostTensor>();
1062
1063     vector<float> input{-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f};
1064     ASSERT_TRUE(
1065         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{11}, input)}));
1066     EXPECT_EQ(result->get_element_type(), element::f32);
1067     auto result_val = read_vector<float>(result);
1068     std::transform(
1069         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::asin(x); });
1070
1071     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1072 }
1073
1074 TEST(eval, evaluate_atan)
1075 {
1076     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
1077     auto atan = make_shared<op::Atan>(p);
1078     auto fun = make_shared<Function>(OutputVector{atan}, ParameterVector{p});
1079     auto result = make_shared<HostTensor>();
1080
1081     vector<float> input{-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f};
1082     ASSERT_TRUE(
1083         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{11}, input)}));
1084     EXPECT_EQ(result->get_element_type(), element::f32);
1085     auto result_val = read_vector<float>(result);
1086     std::transform(
1087         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::atan(x); });
1088
1089     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1090 }
1091
1092 TEST(eval, evaluate_ceiling)
1093 {
1094     auto p = make_shared<op::Parameter>(element::f32, Shape{2, 2});
1095     auto ceil = make_shared<op::Ceiling>(p);
1096     auto fun = make_shared<Function>(OutputVector{ceil}, ParameterVector{p});
1097     auto result = make_shared<HostTensor>();
1098
1099     vector<float> input{-2.5f, -2.0f, 0.3f, 4.8f};
1100     ASSERT_TRUE(
1101         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{2, 2}, input)}));
1102     EXPECT_EQ(result->get_element_type(), element::f32);
1103     auto result_val = read_vector<float>(result);
1104     vector<float> expec{-2.0f, -2.0f, 1.0f, 5.0f};
1105     ASSERT_EQ(result_val, expec);
1106 }
1107
1108 TEST(eval, evaluate_cos)
1109 {
1110     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
1111     auto cos = make_shared<op::Cos>(p);
1112     auto fun = make_shared<Function>(OutputVector{cos}, ParameterVector{p});
1113     auto result = make_shared<HostTensor>();
1114
1115     vector<float> input{0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f};
1116     ASSERT_TRUE(
1117         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{11}, input)}));
1118     EXPECT_EQ(result->get_element_type(), element::f32);
1119     auto result_val = read_vector<float>(result);
1120     std::transform(
1121         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::cos(x); });
1122
1123     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1124 }
1125
1126 TEST(eval, evaluate_cosh)
1127 {
1128     auto p = make_shared<op::Parameter>(element::f32, Shape{6});
1129     auto cosh = make_shared<op::Cosh>(p);
1130     auto fun = make_shared<Function>(OutputVector{cosh}, ParameterVector{p});
1131     auto result = make_shared<HostTensor>();
1132
1133     vector<float> input{1.0f, 0.0f, -0.0f, -1.0f, 5.0f, -5.0f};
1134     ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{6}, input)}));
1135     EXPECT_EQ(result->get_element_type(), element::f32);
1136     auto result_val = read_vector<float>(result);
1137     std::transform(
1138         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::cosh(x); });
1139
1140     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1141 }
1142
1143 TEST(eval, evaluate_tan)
1144 {
1145     auto p = make_shared<op::Parameter>(element::f32, Shape{11});
1146     auto tan = make_shared<op::Tan>(p);
1147     auto fun = make_shared<Function>(OutputVector{tan}, ParameterVector{p});
1148     auto result = make_shared<HostTensor>();
1149
1150     vector<float> input{0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f};
1151     ASSERT_TRUE(
1152         fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{11}, input)}));
1153     EXPECT_EQ(result->get_element_type(), element::f32);
1154     auto result_val = read_vector<float>(result);
1155     std::transform(
1156         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::tan(x); });
1157
1158     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1159 }
1160
1161 TEST(eval, evaluate_tanh)
1162 {
1163     auto p = make_shared<op::Parameter>(element::f32, Shape{6});
1164     auto tanh = make_shared<op::Tanh>(p);
1165     auto fun = make_shared<Function>(OutputVector{tanh}, ParameterVector{p});
1166     auto result = make_shared<HostTensor>();
1167
1168     vector<float> input{1.0f, 0.0f, -0.0f, -1.0f, 0.5f, -0.5f};
1169     ASSERT_TRUE(fun->evaluate({result}, {make_host_tensor<element::Type_t::f32>(Shape{6}, input)}));
1170     EXPECT_EQ(result->get_element_type(), element::f32);
1171     auto result_val = read_vector<float>(result);
1172     std::transform(
1173         input.begin(), input.end(), input.begin(), [](float x) -> float { return std::tanh(x); });
1174
1175     ASSERT_FLOAT_VECTORS_EQ(input, result_val);
1176 }
1177
1178 TEST(eval, evaluate_not)
1179 {
1180     auto p = make_shared<op::Parameter>(element::boolean, Shape{2, 2});
1181     auto op_not = make_shared<op::Not>(p);
1182     auto fun = make_shared<Function>(OutputVector{op_not}, ParameterVector{p});
1183     auto result = make_shared<HostTensor>();
1184
1185     ASSERT_TRUE(fun->evaluate(
1186         {result}, {make_host_tensor<element::Type_t::boolean>(Shape{2, 2}, {1, 0, 1, 0})}));
1187     EXPECT_EQ(result->get_element_type(), element::boolean);
1188     auto result_val = read_vector<char>(result);
1189     vector<char> expec{0, 1, 0, 1};
1190     ASSERT_EQ(result_val, expec);
1191 }
1192
1193 TEST(eval, evaluate_not_i32)
1194 {
1195     auto p = make_shared<op::Parameter>(element::i32, Shape{2, 2});
1196     auto op_not = make_shared<op::Not>(p);
1197     auto fun = make_shared<Function>(OutputVector{op_not}, ParameterVector{p});
1198     auto result = make_shared<HostTensor>();
1199
1200     ASSERT_TRUE(fun->evaluate(
1201         {result}, {make_host_tensor<element::Type_t::i32>(Shape{2, 2}, {100, 0, -2, 0})}));
1202     EXPECT_EQ(result->get_element_type(), element::i32);
1203     auto result_val = read_vector<int32_t>(result);
1204     vector<int32_t> expec{0, 1, 0, 1};
1205     ASSERT_EQ(result_val, expec);
1206 }
1207
1208 TEST(eval, evaluate_logical_not)
1209 {
1210     auto p = make_shared<op::Parameter>(element::boolean, Shape{2, 2});
1211     auto logical_not = make_shared<op::v1::LogicalNot>(p);
1212     auto fun = make_shared<Function>(OutputVector{logical_not}, ParameterVector{p});
1213     auto result = make_shared<HostTensor>();
1214
1215     ASSERT_TRUE(fun->evaluate(
1216         {result}, {make_host_tensor<element::Type_t::boolean>(Shape{2, 2}, {1, 0, 1, 0})}));
1217     EXPECT_EQ(result->get_element_type(), element::boolean);
1218     auto result_val = read_vector<char>(result);
1219     vector<char> expec{0, 1, 0, 1};
1220     ASSERT_EQ(result_val, expec);
1221 }
1222
1223 TEST(eval, evaluate_dynamic_gather)
1224 {
1225     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1226     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1227     auto gather = make_shared<op::v0::Gather>(arg1, arg2);
1228     auto fun = make_shared<Function>(OutputVector{gather}, ParameterVector{arg1, arg2});
1229     auto result_tensor = make_shared<HostTensor>();
1230     ASSERT_TRUE(fun->evaluate({result_tensor},
1231                               {make_host_tensor<element::Type_t::f32>({3}, {1.0f, 2.0f, 3.0f}),
1232                                make_host_tensor<element::Type_t::i32>({2}, {1, 0})}));
1233     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1234     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{2}));
1235     auto cval = read_vector<float>(result_tensor);
1236     vector<float> out{2.0f, 1.0f};
1237     ASSERT_EQ(cval, out);
1238 }
1239
1240 TEST(eval, evaluate_dynamic_axis_gather)
1241 {
1242     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1243     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1244     auto arg3 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1245     auto gather = make_shared<op::v1::Gather>(arg1, arg2, arg3);
1246     auto fun = make_shared<Function>(OutputVector{gather}, ParameterVector{arg1, arg2, arg3});
1247     auto result_tensor = make_shared<HostTensor>();
1248     ASSERT_TRUE(fun->evaluate({result_tensor},
1249                               {make_host_tensor<element::Type_t::f32>(
1250                                    {3, 3}, {1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f, 3.0f, 3.1f, 3.2f}),
1251                                make_host_tensor<element::Type_t::i32>({1, 2}, {0, 2}),
1252                                make_host_tensor<element::Type_t::u64>({}, {1})}));
1253     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1254     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 1, 2}));
1255     auto cval = read_vector<float>(result_tensor);
1256     vector<float> out{1.0f, 1.2f, 2.0f, 2.2f, 3.0f, 3.2f};
1257     ASSERT_EQ(cval, out);
1258 }
1259
1260 TEST(eval, evaluate_dynamic_concat)
1261 {
1262     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1263     auto arg2 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1264     auto concat = make_shared<op::v0::Concat>(NodeVector{arg1, arg2}, 1);
1265     auto fun = make_shared<Function>(OutputVector{concat}, ParameterVector{arg1, arg2});
1266     auto result_tensor = make_shared<HostTensor>();
1267     ASSERT_TRUE(fun->evaluate({result_tensor},
1268                               {make_host_tensor<element::Type_t::f32>({1, 1}, {1.0f}),
1269                                make_host_tensor<element::Type_t::f32>({1, 2}, {8.0f, 10.0f})}));
1270     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1271     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{1, 3}));
1272     auto cval = read_vector<float>(result_tensor);
1273     vector<float> out{1.0f, 8.0f, 10.0f};
1274     ASSERT_EQ(cval, out);
1275 }
1276
1277 template <element::Type_t T>
1278 void test_eval(shared_ptr<Function> fun,
1279                vector<vector<float>>& inputs,
1280                vector<Shape>& x_shapes,
1281                vector<Shape>& result_shapes,
1282                vector<vector<float>>& results)
1283 {
1284     using IN_T = typename element_type_traits<T>::value_type;
1285     std::vector<std::vector<IN_T>> perms{{0, 1}, {1, 0}, {2, 1, 0}};
1286     for (size_t i = 0; i < x_shapes.size(); i++)
1287     {
1288         auto result_tensor = make_shared<HostTensor>();
1289         ASSERT_TRUE(fun->evaluate({result_tensor},
1290                                   {make_host_tensor<element::Type_t::f32>(x_shapes[i], inputs[i]),
1291                                    make_host_tensor<T>(Shape{perms[i].size()}, perms[i])}));
1292
1293         ASSERT_EQ(result_tensor->get_shape(), result_shapes[i]);
1294         auto actual_results = read_vector<float>(result_tensor);
1295         ASSERT_EQ(actual_results, results[i]);
1296     }
1297 }
1298
1299 TEST(eval, eval_transpose)
1300 {
1301     auto x = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1302     vector<shared_ptr<op::Parameter>> axes;
1303     axes.push_back(make_shared<op::Parameter>(element::i8, PartialShape{Dimension::dynamic()}));
1304     axes.push_back(make_shared<op::Parameter>(element::i16, PartialShape{Dimension::dynamic()}));
1305     axes.push_back(make_shared<op::Parameter>(element::i32, PartialShape{Dimension::dynamic()}));
1306     axes.push_back(make_shared<op::Parameter>(element::i64, PartialShape{Dimension::dynamic()}));
1307
1308     axes.push_back(make_shared<op::Parameter>(element::u8, PartialShape{Dimension::dynamic()}));
1309     axes.push_back(make_shared<op::Parameter>(element::u16, PartialShape{Dimension::dynamic()}));
1310     axes.push_back(make_shared<op::Parameter>(element::u32, PartialShape{Dimension::dynamic()}));
1311     axes.push_back(make_shared<op::Parameter>(element::u64, PartialShape{Dimension::dynamic()}));
1312
1313     std::vector<Shape> x_shapes{Shape{2, 3}, Shape{2, 3}, Shape{2, 2, 3}};
1314
1315     std::vector<std::vector<float>> inputs{
1316         {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}};
1317     std::vector<Shape> result_shapes{Shape{2, 3}, Shape{3, 2}, {3, 2, 2}};
1318     std::vector<std::vector<float>> results{
1319         {1, 2, 3, 4, 5, 6}, {1, 4, 2, 5, 3, 6}, {1, 7, 4, 10, 2, 8, 5, 11, 3, 9, 6, 12}};
1320
1321     for (auto& axis : axes)
1322     {
1323         auto x_transpose = make_shared<op::v1::Transpose>(x, axis);
1324         auto fun = make_shared<Function>(NodeVector{x_transpose}, ParameterVector{x, axis});
1325
1326         switch (axis->get_element_type())
1327         {
1328         case element::Type_t::i8:
1329             test_eval<element::Type_t::i8>(fun, inputs, x_shapes, result_shapes, results);
1330             break;
1331         case element::Type_t::i16:
1332             test_eval<element::Type_t::i16>(fun, inputs, x_shapes, result_shapes, results);
1333             break;
1334         case element::Type_t::i32:
1335             test_eval<element::Type_t::i32>(fun, inputs, x_shapes, result_shapes, results);
1336             break;
1337         case element::Type_t::i64:
1338             test_eval<element::Type_t::i64>(fun, inputs, x_shapes, result_shapes, results);
1339             break;
1340         case element::Type_t::u8:
1341             test_eval<element::Type_t::u8>(fun, inputs, x_shapes, result_shapes, results);
1342             break;
1343         case element::Type_t::u16:
1344             test_eval<element::Type_t::u16>(fun, inputs, x_shapes, result_shapes, results);
1345             break;
1346         case element::Type_t::u32:
1347             test_eval<element::Type_t::u32>(fun, inputs, x_shapes, result_shapes, results);
1348             break;
1349         case element::Type_t::u64:
1350             test_eval<element::Type_t::u64>(fun, inputs, x_shapes, result_shapes, results);
1351             break;
1352         default: NGRAPH_CHECK(false, "Invalid type"); break;
1353         }
1354     }
1355 }
1356
1357 TEST(eval, max_pool_v1_dynamic)
1358 {
1359     Shape window_shape{3};
1360     auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1361     auto f = make_shared<Function>(
1362         make_shared<op::v1::MaxPool>(
1363             A, Strides(), Shape(), Shape(), window_shape, op::RoundingType::FLOOR),
1364         ParameterVector{A});
1365     auto result_tensor = make_shared<HostTensor>();
1366
1367     ASSERT_TRUE(f->evaluate({result_tensor},
1368                             {make_host_tensor<element::Type_t::f32>(
1369                                 {1, 1, 14}, {0, 1, 0, 2, 1, 0, 3, 2, 0, 0, 2, 0, 0, 0})}));
1370
1371     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1372     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{1, 1, 12}));
1373     auto cval = read_vector<float>(result_tensor);
1374     vector<float> out{1, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 0};
1375 }
1376
1377 TEST(eval, evaluate_static_scatter_elements_update_basic)
1378 {
1379     const Shape data_shape{3, 3};
1380     const Shape indices_shape{2, 3};
1381     auto arg1 = make_shared<op::Parameter>(element::f32, data_shape);
1382     auto arg2 = make_shared<op::Parameter>(element::i32, indices_shape);
1383     auto arg3 = make_shared<op::Parameter>(element::f32, indices_shape);
1384     auto arg4 = make_shared<op::Parameter>(element::i64, Shape{});
1385     auto scatter_elements_update =
1386         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1387     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1388                                      ParameterVector{arg1, arg2, arg3, arg4});
1389     auto result_tensor = make_shared<HostTensor>();
1390     ASSERT_TRUE(
1391         fun->evaluate({result_tensor},
1392                       {make_host_tensor<element::Type_t::f32>(
1393                            data_shape, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}),
1394                        make_host_tensor<element::Type_t::i32>(indices_shape, {1, 0, 2, 0, 2, 1}),
1395                        make_host_tensor<element::Type_t::f32>(indices_shape,
1396                                                               {1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f}),
1397                        make_host_tensor<element::Type_t::i64>({}, {0})}));
1398     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1399     EXPECT_EQ(result_tensor->get_shape(), (Shape{3, 3}));
1400     auto cval = read_vector<float>(result_tensor);
1401     vector<float> out{2.f, 1.1f, 0.0f, 1.f, 0.0f, 2.2f, 0.f, 2.1f, 1.2f};
1402     ASSERT_EQ(cval, out);
1403 }
1404
1405 TEST(eval, evaluate_dynamic_scatter_elements_update_basic)
1406 {
1407     const Shape data_shape{3, 3};
1408     const Shape indices_shape{2, 3};
1409
1410     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1411     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1412     auto arg3 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1413     auto arg4 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1414
1415     auto scatter_elements_update =
1416         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1417     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1418                                      ParameterVector{arg1, arg2, arg3, arg4});
1419     auto result_tensor = make_shared<HostTensor>();
1420     ASSERT_TRUE(
1421         fun->evaluate({result_tensor},
1422                       {make_host_tensor<element::Type_t::f32>(
1423                            data_shape, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}),
1424                        make_host_tensor<element::Type_t::i32>(indices_shape, {1, 0, 2, 0, 2, 1}),
1425                        make_host_tensor<element::Type_t::f32>(indices_shape,
1426                                                               {1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f}),
1427                        make_host_tensor<element::Type_t::i64>({}, {0})}));
1428
1429     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1430     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 3}));
1431     auto cval = read_vector<float>(result_tensor);
1432     vector<float> out{2.f, 1.1f, 0.0f, 1.f, 0.0f, 2.2f, 0.f, 2.1f, 1.2f};
1433     ASSERT_EQ(cval, out);
1434 }
1435
1436 TEST(eval, evaluate_dynamic_scatter_elements_update_negative_axis)
1437 {
1438     const Shape data_shape{3, 3};
1439     const Shape indices_shape{2, 3};
1440     const Shape axis_shape{};
1441
1442     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1443     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1444     auto arg3 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1445     auto arg4 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1446
1447     auto scatter_elements_update =
1448         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1449     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1450                                      ParameterVector{arg1, arg2, arg3, arg4});
1451     auto result_tensor = make_shared<HostTensor>();
1452     ASSERT_TRUE(
1453         fun->evaluate({result_tensor},
1454                       {make_host_tensor<element::Type_t::f32>(
1455                            data_shape, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}),
1456                        make_host_tensor<element::Type_t::i32>(indices_shape, {1, 0, 2, 0, 2, 1}),
1457                        make_host_tensor<element::Type_t::f32>(indices_shape,
1458                                                               {1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f}),
1459                        make_host_tensor<element::Type_t::i64>(axis_shape, {-1})}));
1460
1461     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1462     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 3}));
1463     auto cval = read_vector<float>(result_tensor);
1464     vector<float> out{1.1f, 1.0f, 1.2f, 2.0f, 2.2f, 2.1f, 0.0f, 0.0f, 0.0f};
1465     ASSERT_EQ(cval, out);
1466 }
1467
1468 TEST(eval, evaluate_dynamic_scatter_elements_update_1d_axis)
1469 {
1470     const Shape data_shape{3, 3};
1471     const Shape indices_shape{2, 3};
1472
1473     auto arg1 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1474     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1475     auto arg3 = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1476     auto arg4 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1477
1478     auto scatter_elements_update =
1479         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1480     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1481                                      ParameterVector{arg1, arg2, arg3, arg4});
1482     auto result_tensor = make_shared<HostTensor>();
1483     ASSERT_TRUE(
1484         fun->evaluate({result_tensor},
1485                       {make_host_tensor<element::Type_t::f32>(
1486                            data_shape, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f}),
1487                        make_host_tensor<element::Type_t::i32>(indices_shape, {1, 0, 2, 0, 2, 1}),
1488                        make_host_tensor<element::Type_t::f32>(indices_shape,
1489                                                               {1.0f, 1.1f, 1.2f, 2.0f, 2.1f, 2.2f}),
1490                        make_host_tensor<element::Type_t::i64>({1}, {0})}));
1491
1492     EXPECT_EQ(result_tensor->get_element_type(), element::f32);
1493     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 3}));
1494     auto cval = read_vector<float>(result_tensor);
1495     vector<float> out{2.f, 1.1f, 0.0f, 1.f, 0.0f, 2.2f, 0.f, 2.1f, 1.2f};
1496     ASSERT_EQ(cval, out);
1497 }
1498
1499 // Disabled test for disabled reference implementation
1500 TEST(eval, DISABLED_evaluate_dynamic_scatter_elements_update_3d_i16)
1501 {
1502     const Shape data_shape{3, 3, 3};
1503     const Shape indices_shape{2, 2, 3};
1504
1505     auto arg1 = make_shared<op::Parameter>(element::i16, PartialShape::dynamic());
1506     auto arg2 = make_shared<op::Parameter>(element::i16, PartialShape::dynamic());
1507     auto arg3 = make_shared<op::Parameter>(element::i16, PartialShape::dynamic());
1508     auto arg4 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1509
1510     auto scatter_elements_update =
1511         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1512     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1513                                      ParameterVector{arg1, arg2, arg3, arg4});
1514     auto result_tensor = make_shared<HostTensor>();
1515     ASSERT_TRUE(fun->evaluate({result_tensor},
1516                               {make_host_tensor<element::Type_t::i16>(
1517                                    data_shape, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1518                                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
1519                                make_host_tensor<element::Type_t::i16>(
1520                                    indices_shape, {1, 0, 2, 0, 2, 1, 2, 2, 2, 0, 1, 0}),
1521                                make_host_tensor<element::Type_t::i16>(
1522                                    indices_shape, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
1523                                make_host_tensor<element::Type_t::i64>({}, {1})}));
1524
1525     EXPECT_EQ(result_tensor->get_element_type(), element::i16);
1526     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 3, 3}));
1527     auto cval = read_vector<int16_t>(result_tensor);
1528     vector<int16_t> out{4, 2, 0, 1, 0, 6, 0, 5, 3, 10, 0, 12, 0, 11,
1529                         0, 7, 8, 9, 0, 0, 0, 0, 0, 0,  0, 0,  0};
1530     ASSERT_EQ(cval, out);
1531 }
1532
1533 TEST(eval, evaluate_dynamic_scatter_elements_update_one_elem_i32)
1534 {
1535     const Shape data_shape{3, 3, 3};
1536     const Shape indices_shape{1, 1, 1};
1537
1538     auto arg1 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1539     auto arg2 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1540     auto arg3 = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
1541     auto arg4 = make_shared<op::Parameter>(element::i64, PartialShape::dynamic());
1542
1543     auto scatter_elements_update =
1544         make_shared<op::v3::ScatterElementsUpdate>(arg1, arg2, arg3, arg4);
1545     auto fun = make_shared<Function>(OutputVector{scatter_elements_update},
1546                                      ParameterVector{arg1, arg2, arg3, arg4});
1547     auto result_tensor = make_shared<HostTensor>();
1548     ASSERT_TRUE(fun->evaluate({result_tensor},
1549                               {make_host_tensor<element::Type_t::i32>(
1550                                    data_shape, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1551                                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
1552                                make_host_tensor<element::Type_t::i32>(indices_shape, {1}),
1553                                make_host_tensor<element::Type_t::i32>(indices_shape, {2}),
1554                                make_host_tensor<element::Type_t::i64>({}, {0})}));
1555
1556     EXPECT_EQ(result_tensor->get_element_type(), element::i32);
1557     EXPECT_EQ(result_tensor->get_partial_shape(), (PartialShape{3, 3, 3}));
1558     auto cval = read_vector<int32_t>(result_tensor);
1559     vector<int32_t> out{0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0,
1560                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1561     ASSERT_EQ(cval, out);
1562 }
1563
1564 TEST(eval, topk_v1)
1565 {
1566     Shape shape{2, 3, 2};
1567     Shape rshape{2, 2, 2};
1568
1569     auto A = make_shared<op::Parameter>(element::f32, shape);
1570     const auto k = op::Constant::create(element::i32, Shape{}, {2});
1571     auto B = make_shared<op::v1::TopK>(A, k, 1, "max", "index", element::i32);
1572
1573     auto fun = make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A});
1574
1575     auto result0 = make_shared<HostTensor>();
1576     auto result1 = make_shared<HostTensor>();
1577     ASSERT_TRUE(fun->evaluate({result0, result1},
1578                               {make_host_tensor<element::Type_t::f32>(
1579                                   Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7})}));
1580     EXPECT_EQ(result0->get_element_type(), element::f32);
1581     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1582     EXPECT_EQ(result1->get_element_type(), element::i32);
1583     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1584     auto result0_val = read_vector<float>(result0);
1585
1586     auto result1_val = read_vector<int32_t>(result1);
1587
1588     vector<float> expec0{12, 9, 10, 4, 6, 3, 11, 7};
1589     ASSERT_EQ(result0_val, expec0);
1590
1591     vector<int32_t> expec1{0, 1, 1, 2, 0, 1, 2, 2};
1592     ASSERT_EQ(result1_val, expec1);
1593 }
1594
1595 TEST(eval, topk_v1_dyn)
1596 {
1597     Shape shape{2, 3, 2};
1598
1599     auto A = make_shared<op::Parameter>(element::f32, shape);
1600     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1601     auto B = make_shared<op::v1::TopK>(A, k, 1, "max", "index", element::i32);
1602
1603     auto fun =
1604         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1605
1606     auto result0 = make_shared<HostTensor>();
1607     auto result1 = make_shared<HostTensor>();
1608     ASSERT_TRUE(fun->evaluate({result0, result1},
1609                               {make_host_tensor<element::Type_t::f32>(
1610                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1611                                make_host_tensor<element::Type_t::i32>(Shape{}, {2})}));
1612     EXPECT_EQ(result0->get_element_type(), element::f32);
1613     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1614     EXPECT_EQ(result1->get_element_type(), element::i32);
1615     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1616     auto result0_val = read_vector<float>(result0);
1617     auto result1_val = read_vector<int32_t>(result1);
1618     vector<float> expec0{12, 9, 10, 4, 6, 3, 11, 7};
1619     ASSERT_EQ(result0_val, expec0);
1620
1621     vector<int32_t> expec1{0, 1, 1, 2, 0, 1, 2, 2};
1622     ASSERT_EQ(result1_val, expec1);
1623 }
1624
1625 TEST(eval, topk_v3_dyn)
1626 {
1627     Shape shape{2, 3, 2};
1628
1629     auto A = make_shared<op::Parameter>(element::f32, shape);
1630     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1631     auto B = make_shared<op::v3::TopK>(A, k, 1, "max", "index", element::i32);
1632
1633     auto fun =
1634         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1635
1636     auto result0 = make_shared<HostTensor>();
1637     auto result1 = make_shared<HostTensor>();
1638     ASSERT_TRUE(fun->evaluate({result0, result1},
1639                               {make_host_tensor<element::Type_t::f32>(
1640                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1641                                make_host_tensor<element::Type_t::i32>(Shape{}, {2})}));
1642     EXPECT_EQ(result0->get_element_type(), element::f32);
1643     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1644     EXPECT_EQ(result1->get_element_type(), element::i32);
1645     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1646     auto result0_val = read_vector<float>(result0);
1647     auto result1_val = read_vector<int32_t>(result1);
1648     vector<float> expec0{12, 9, 10, 4, 6, 3, 11, 7};
1649     ASSERT_EQ(result0_val, expec0);
1650
1651     vector<int32_t> expec1{0, 1, 1, 2, 0, 1, 2, 2};
1652     ASSERT_EQ(result1_val, expec1);
1653 }
1654
1655 TEST(eval, topk_v3_dyn_values)
1656 {
1657     Shape shape{2, 3, 2};
1658
1659     auto A = make_shared<op::Parameter>(element::f32, shape);
1660     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1661     auto B = make_shared<op::v3::TopK>(A, k, 1, "max", "value", element::i32);
1662
1663     auto fun =
1664         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1665
1666     auto result0 = make_shared<HostTensor>();
1667     auto result1 = make_shared<HostTensor>();
1668     ASSERT_TRUE(fun->evaluate({result0, result1},
1669                               {make_host_tensor<element::Type_t::f32>(
1670                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1671                                make_host_tensor<element::Type_t::i32>(Shape{}, {2})}));
1672     EXPECT_EQ(result0->get_element_type(), element::f32);
1673     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1674     EXPECT_EQ(result1->get_element_type(), element::i32);
1675     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1676     auto result0_val = read_vector<float>(result0);
1677     auto result1_val = read_vector<int32_t>(result1);
1678     vector<float> expec0{12, 9, 10, 4, 11, 7, 6, 3};
1679     ASSERT_EQ(result0_val, expec0);
1680
1681     vector<int32_t> expec1{0, 1, 1, 2, 2, 2, 0, 1};
1682     ASSERT_EQ(result1_val, expec1);
1683 }
1684
1685 TEST(eval, topk_v3_dyn_values_k0)
1686 {
1687     Shape shape{2, 3, 2};
1688
1689     auto A = make_shared<op::Parameter>(element::f32, shape);
1690     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1691     auto B = make_shared<op::v3::TopK>(A, k, 1, "max", "value", element::i32);
1692
1693     auto fun =
1694         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1695
1696     auto result0 = make_shared<HostTensor>();
1697     auto result1 = make_shared<HostTensor>();
1698     ASSERT_TRUE(fun->evaluate({result0, result1},
1699                               {make_host_tensor<element::Type_t::f32>(
1700                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1701                                make_host_tensor<element::Type_t::i32>(Shape{}, {0})}));
1702     EXPECT_EQ(result0->get_element_type(), element::f32);
1703     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 3, 2}));
1704     EXPECT_EQ(result1->get_element_type(), element::i32);
1705     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 3, 2}));
1706     auto result0_val = read_vector<float>(result0);
1707     auto result1_val = read_vector<int32_t>(result1);
1708     vector<float> expec0{12, 9, 10, 4, 8, 2, 11, 7, 6, 3, 5, 1};
1709     ASSERT_EQ(result0_val, expec0);
1710
1711     vector<int32_t> expec1{0, 1, 1, 2, 2, 0, 2, 2, 0, 1, 1, 0};
1712     ASSERT_EQ(result1_val, expec1);
1713 }
1714
1715 TEST(eval, topk_v0_dyn)
1716 {
1717     Shape shape{2, 3, 2};
1718
1719     auto A = make_shared<op::Parameter>(element::f32, shape);
1720     auto k = make_shared<op::Parameter>(element::i64, Shape{});
1721     auto axis = make_shared<op::Parameter>(element::i64, Shape{});
1722
1723     element::Type result_et{element::i32};
1724     bool compute_max = true;
1725
1726     auto B = make_shared<op::v0::TopK>(
1727         A, k, axis, result_et, compute_max, op::v0::TopK::SortType::SORT_VALUES);
1728
1729     auto fun = make_shared<Function>(OutputVector{B->output(0), B->output(1)},
1730                                      ParameterVector{A, k, axis});
1731
1732     auto result0 = make_shared<HostTensor>();
1733     auto result1 = make_shared<HostTensor>();
1734     ASSERT_TRUE(fun->evaluate({result0, result1},
1735                               {make_host_tensor<element::Type_t::f32>(
1736                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1737                                make_host_tensor<element::Type_t::i64>(Shape{}, {2}),
1738                                make_host_tensor<element::Type_t::i64>(Shape{}, {1})}));
1739     EXPECT_EQ(result0->get_element_type(), element::i32);
1740     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1741     EXPECT_EQ(result1->get_element_type(), element::f32);
1742     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1743     auto result1_val = read_vector<float>(result1);
1744     auto result0_val = read_vector<int32_t>(result0);
1745
1746     vector<float> expec1{12, 9, 10, 4, 11, 7, 6, 3};
1747     ASSERT_EQ(result1_val, expec1);
1748
1749     vector<int32_t> expec0{0, 1, 1, 2, 2, 2, 0, 1};
1750     ASSERT_EQ(result0_val, expec0);
1751 }
1752
1753 TEST(eval, topk_v0_dyn_k0)
1754 {
1755     Shape shape{2, 3, 2};
1756
1757     auto A = make_shared<op::Parameter>(element::f32, shape);
1758     auto k = make_shared<op::Parameter>(element::i64, Shape{});
1759     auto axis = make_shared<op::Parameter>(element::i64, Shape{});
1760
1761     element::Type result_et{element::i32};
1762     bool compute_max = true;
1763
1764     auto B = make_shared<op::v0::TopK>(
1765         A, k, axis, result_et, compute_max, op::v0::TopK::SortType::SORT_VALUES);
1766
1767     auto fun = make_shared<Function>(OutputVector{B->output(0), B->output(1)},
1768                                      ParameterVector{A, k, axis});
1769
1770     auto result0 = make_shared<HostTensor>();
1771     auto result1 = make_shared<HostTensor>();
1772     ASSERT_TRUE(fun->evaluate({result0, result1},
1773                               {make_host_tensor<element::Type_t::f32>(
1774                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1775                                make_host_tensor<element::Type_t::i64>(Shape{}, {0}),
1776                                make_host_tensor<element::Type_t::i64>(Shape{}, {1})}));
1777     EXPECT_EQ(result0->get_element_type(), element::i32);
1778     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 3, 2}));
1779     EXPECT_EQ(result1->get_element_type(), element::f32);
1780     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 3, 2}));
1781     auto result1_val = read_vector<float>(result1);
1782     auto result0_val = read_vector<int32_t>(result0);
1783
1784     vector<float> expec1{12, 9, 10, 4, 8, 2, 11, 7, 6, 3, 5, 1};
1785     ASSERT_EQ(result1_val, expec1);
1786
1787     vector<int32_t> expec0{0, 1, 1, 2, 2, 0, 2, 2, 0, 1, 1, 0};
1788     ASSERT_EQ(result0_val, expec0);
1789 }
1790
1791 TEST(eval, topk_v3_param_dyn_values_k0)
1792 {
1793     auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1794     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1795     auto B = make_shared<op::v3::TopK>(A, k, 1, "max", "value", element::i32);
1796
1797     auto fun =
1798         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1799
1800     auto result0 = make_shared<HostTensor>();
1801     auto result1 = make_shared<HostTensor>();
1802     ASSERT_TRUE(fun->evaluate({result0, result1},
1803                               {make_host_tensor<element::Type_t::f32>(
1804                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1805                                make_host_tensor<element::Type_t::i32>(Shape{}, {0})}));
1806     EXPECT_EQ(result0->get_element_type(), element::f32);
1807     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 3, 2}));
1808     EXPECT_EQ(result1->get_element_type(), element::i32);
1809     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 3, 2}));
1810     auto result0_val = read_vector<float>(result0);
1811     auto result1_val = read_vector<int32_t>(result1);
1812     vector<float> expec0{12, 9, 10, 4, 8, 2, 11, 7, 6, 3, 5, 1};
1813     ASSERT_EQ(result0_val, expec0);
1814
1815     vector<int32_t> expec1{0, 1, 1, 2, 2, 0, 2, 2, 0, 1, 1, 0};
1816     ASSERT_EQ(result1_val, expec1);
1817 }
1818
1819 TEST(eval, topk_v3_param_dyn_values_k2)
1820 {
1821     auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1822     auto k = make_shared<op::Parameter>(element::u32, Shape{});
1823     auto B = make_shared<op::v3::TopK>(A, k, 1, "max", "value", element::i32);
1824
1825     auto fun =
1826         make_shared<Function>(OutputVector{B->output(0), B->output(1)}, ParameterVector{A, k});
1827
1828     auto result0 = make_shared<HostTensor>();
1829     auto result1 = make_shared<HostTensor>();
1830     ASSERT_TRUE(fun->evaluate({result0, result1},
1831                               {make_host_tensor<element::Type_t::f32>(
1832                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1833                                make_host_tensor<element::Type_t::i32>(Shape{}, {2})}));
1834     EXPECT_EQ(result0->get_element_type(), element::f32);
1835     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1836     EXPECT_EQ(result1->get_element_type(), element::i32);
1837     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1838     auto result0_val = read_vector<float>(result0);
1839     auto result1_val = read_vector<int32_t>(result1);
1840     vector<float> expec0{12, 9, 10, 4, 11, 7, 6, 3};
1841     ASSERT_EQ(result0_val, expec0);
1842
1843     vector<int32_t> expec1{0, 1, 1, 2, 2, 2, 0, 1};
1844     ASSERT_EQ(result1_val, expec1);
1845 }
1846
1847 TEST(eval, topk_v0_param_dyn_k2)
1848 {
1849     auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1850     auto k = make_shared<op::Parameter>(element::i64, Shape{});
1851     auto axis = make_shared<op::Parameter>(element::i64, Shape{});
1852
1853     element::Type result_et{element::i32};
1854     bool compute_max = true;
1855
1856     auto B = make_shared<op::v0::TopK>(
1857         A, k, axis, result_et, compute_max, op::v0::TopK::SortType::SORT_VALUES);
1858
1859     auto fun = make_shared<Function>(OutputVector{B->output(0), B->output(1)},
1860                                      ParameterVector{A, k, axis});
1861
1862     auto result0 = make_shared<HostTensor>();
1863     auto result1 = make_shared<HostTensor>();
1864     ASSERT_TRUE(fun->evaluate({result0, result1},
1865                               {make_host_tensor<element::Type_t::f32>(
1866                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1867                                make_host_tensor<element::Type_t::i64>(Shape{}, {2}),
1868                                make_host_tensor<element::Type_t::i64>(Shape{}, {1})}));
1869     EXPECT_EQ(result0->get_element_type(), element::i32);
1870     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 2, 2}));
1871     EXPECT_EQ(result1->get_element_type(), element::f32);
1872     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 2, 2}));
1873     auto result1_val = read_vector<float>(result1);
1874     auto result0_val = read_vector<int32_t>(result0);
1875
1876     vector<float> expec1{12, 9, 10, 4, 11, 7, 6, 3};
1877     ASSERT_EQ(result1_val, expec1);
1878
1879     vector<int32_t> expec0{0, 1, 1, 2, 2, 2, 0, 1};
1880     ASSERT_EQ(result0_val, expec0);
1881 }
1882
1883 TEST(eval, topk_v0_param_dyn_k0)
1884 {
1885     auto A = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
1886     auto k = make_shared<op::Parameter>(element::i64, Shape{});
1887     auto axis = make_shared<op::Parameter>(element::i64, Shape{});
1888
1889     element::Type result_et{element::i32};
1890     bool compute_max = true;
1891
1892     auto B = make_shared<op::v0::TopK>(
1893         A, k, axis, result_et, compute_max, op::v0::TopK::SortType::SORT_VALUES);
1894
1895     auto fun = make_shared<Function>(OutputVector{B->output(0), B->output(1)},
1896                                      ParameterVector{A, k, axis});
1897
1898     auto result0 = make_shared<HostTensor>();
1899     auto result1 = make_shared<HostTensor>();
1900     ASSERT_TRUE(fun->evaluate({result0, result1},
1901                               {make_host_tensor<element::Type_t::f32>(
1902                                    Shape{2, 3, 2}, {12, 2, 10, 9, 8, 4, 6, 1, 5, 3, 11, 7}),
1903                                make_host_tensor<element::Type_t::i64>(Shape{}, {0}),
1904                                make_host_tensor<element::Type_t::i64>(Shape{}, {1})}));
1905     EXPECT_EQ(result0->get_element_type(), element::i32);
1906     EXPECT_EQ(result0->get_partial_shape(), (PartialShape{2, 3, 2}));
1907     EXPECT_EQ(result1->get_element_type(), element::f32);
1908     EXPECT_EQ(result1->get_partial_shape(), (PartialShape{2, 3, 2}));
1909     auto result1_val = read_vector<float>(result1);
1910     auto result0_val = read_vector<int32_t>(result0);
1911
1912     vector<float> expec1{12, 9, 10, 4, 8, 2, 11, 7, 6, 3, 5, 1};
1913     ASSERT_EQ(result1_val, expec1);
1914
1915     vector<int32_t> expec0{0, 1, 1, 2, 2, 0, 2, 2, 0, 1, 1, 0};
1916     ASSERT_EQ(result0_val, expec0);
1917 }
1918
1919 TEST(eval, reduce_logical_and__neg_axis)
1920 {
1921     const auto data = make_shared<op::Parameter>(element::boolean, Shape{2, 2, 2});
1922     const auto axes = make_shared<op::Parameter>(element::i64, Shape{});
1923
1924     const auto op = make_shared<op::v1::ReduceLogicalAnd>(data, axes);
1925
1926     auto fun = make_shared<Function>(op, ParameterVector{data, axes});
1927
1928     auto result = make_shared<HostTensor>();
1929
1930     // when ReduceLogicalAnd node evaluator returns false -> the Function object throws
1931     EXPECT_THROW(
1932         fun->evaluate({result},
1933                       {
1934                           make_host_tensor<element::Type_t::boolean>(
1935                               Shape{2, 2, 2}, {true, false, true, false, true, false, true, false}),
1936                           make_host_tensor<element::Type_t::i64>(Shape{}, {-1}),
1937                       }),
1938         ngraph::ngraph_error);
1939 }