From 9eb7bfdfc0ec00156dd9cd7539054003a107667e Mon Sep 17 00:00:00 2001 From: Jozef Daniecki Date: Mon, 24 May 2021 12:05:54 +0200 Subject: [PATCH] More unit tests for Convert reference implementation. (#5745) * Add Convert unit tests to check C++ to LP types convertion. * Add unit tests to check LP types to C++ ints. * Disable LP to C++ ints tets in CPU plugin. * Remove f64 support from Convert evaluate. --- .../ngraph/runtime/reference/convert.hpp | 22 +- ngraph/core/src/op/convert.cpp | 13 +- ngraph/test/backend/convert.in.cpp | 961 +++++++++++++++++- ngraph/test/runtime/ie/unit_test.manifest | 87 +- .../runtime/interpreter/evaluates_map.cpp | 66 -- 5 files changed, 1044 insertions(+), 105 deletions(-) diff --git a/ngraph/core/reference/include/ngraph/runtime/reference/convert.hpp b/ngraph/core/reference/include/ngraph/runtime/reference/convert.hpp index 2fce199f7bb..43bc8da26c9 100644 --- a/ngraph/core/reference/include/ngraph/runtime/reference/convert.hpp +++ b/ngraph/core/reference/include/ngraph/runtime/reference/convert.hpp @@ -72,25 +72,25 @@ namespace ngraph } return val; } - template - T get_value(const uint8_t* buf, size_t idx, element::Type type) + template + TO get_value(const uint8_t* buf, size_t idx, element::Type from_type) { - if (type == element::u1) + if (from_type == element::u1) { return detail::get_u1(buf, idx); } - if (type == element::u4) + if (from_type == element::u4) { return detail::get_u4(buf, idx); } - if (type == element::i4) + if (from_type == element::i4) { return detail::get_i4(buf, idx); } - - return static_cast(buf[idx]); + auto v = reinterpret_cast(buf); + return static_cast(v[idx]); } template @@ -107,21 +107,21 @@ namespace ngraph if (dst_type == element::u1) { detail::set_u1( - output, i, detail::get_value(input, i, src_type)); + output, i, detail::get_value(input, i, src_type)); } else if (dst_type == element::u4) { detail::set_u4( - output, i, detail::get_value(input, i, src_type)); + output, i, detail::get_value(input, i, src_type)); } else if (dst_type == element::i4) { detail::set_i4( - output, i, detail::get_value(input, i, src_type)); + output, i, detail::get_value(input, i, src_type)); } else { - out[i] = detail::get_value(input, i, src_type); + out[i] = detail::get_value(input, i, src_type); } } } diff --git a/ngraph/core/src/op/convert.cpp b/ngraph/core/src/op/convert.cpp index 4f585f30572..3bd81768761 100644 --- a/ngraph/core/src/op/convert.cpp +++ b/ngraph/core/src/op/convert.cpp @@ -104,7 +104,6 @@ namespace convert TYPE_OUT_CASE(bf16, arg, out); TYPE_OUT_CASE(f16, arg, out); TYPE_OUT_CASE(f32, arg, out); - TYPE_OUT_CASE(f64, arg, out); TYPE_OUT_CASE(boolean, arg, out); default: rc = false; break; } @@ -119,13 +118,15 @@ namespace convert NGRAPH_TYPE_CASE(evaluate_convert, u1, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, u4, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, u8, arg, out); - NGRAPH_TYPE_CASE(evaluate_convert, i4, arg, out); - NGRAPH_TYPE_CASE(evaluate_convert, i8, arg, out); - NGRAPH_TYPE_CASE(evaluate_convert, i32, arg, out); - NGRAPH_TYPE_CASE(evaluate_convert, i16, arg, out); - NGRAPH_TYPE_CASE(evaluate_convert, i64, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, u16, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, u32, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, u64, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, i4, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, i8, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, i16, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, i32, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, i64, arg, out); + NGRAPH_TYPE_CASE(evaluate_convert, bf16, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, f16, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, f32, arg, out); NGRAPH_TYPE_CASE(evaluate_convert, boolean, arg, out); diff --git a/ngraph/test/backend/convert.in.cpp b/ngraph/test/backend/convert.in.cpp index a3abdd87af3..20cb1d16953 100644 --- a/ngraph/test/backend/convert.in.cpp +++ b/ngraph/test/backend/convert.in.cpp @@ -63,7 +63,7 @@ namespace auto handle = backend->compile(f); handle->call_with_validate({output}, {input_tesnor}); - std::vector result(expected_output.size()); + std::vector result(expected_output.size()); output->read(result.data(), result.size() * sizeof(uint8_t)); EXPECT_TRUE(test::all_close(expected_output, result)); } @@ -351,10 +351,31 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_f32_to_f32) ConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } -// destination: f64 -// not supported by IE, hence no tests - // destination: i4 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_i4) +{ + const std::vector input{0xA0}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{0x10, 0x10}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_i4) +{ + const std::vector input{0x12, 0x03}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{0x12, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i4) { const std::vector input{1, 2, 0, 3}; @@ -364,6 +385,139 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i4) const std::vector expected_output{0x12, 0x03}; const element::Type expected_output_type = ngraph::element::i4; + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u16_to_i4) +{ + const std::vector input{1, 2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u16; + + const std::vector expected_output{0x12, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u32_to_i4) +{ + const std::vector input{1, 2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u32; + + const std::vector expected_output{0x12, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u64_to_i4) +{ + const std::vector input{1, 2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u64; + + const std::vector expected_output{0x12, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i8_to_i4) +{ + const std::vector input{-1, -2, 2, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i8; + + const std::vector expected_output{0xFE, 0x23}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i16_to_i4) +{ + const std::vector input{-1, -2, 2, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i16; + + const std::vector expected_output{0xFE, 0x23}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i32_to_i4) +{ + const std::vector input{-1, -2, 2, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i32; + + const std::vector expected_output{0xFE, 0x23}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i64_to_i4) +{ + const std::vector input{-1, -2, 2, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i64; + + const std::vector expected_output{0xFE, 0x23}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f16_to_i4) +{ + const std::vector input{-1, -2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::f16; + + const std::vector expected_output{0xFE, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_bf16_to_i4) +{ + const std::vector input{-1, -2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::bf16; + + const std::vector expected_output{0xFE, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f32_to_i4) +{ + const std::vector input{-1, -2, 0, 3}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::f32; + + const std::vector expected_output{0xFE, 0x03}; + const element::Type expected_output_type = ngraph::element::i4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +// destination: i8 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_i8) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::i8; + { const auto f = CreateFunction(input_shape, input_type, expected_output_type); auto backend = runtime::Backend::create("${BACKEND_NAME}"); @@ -373,13 +527,60 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i4) auto handle = backend->compile(f); handle->call_with_validate({output}, {input_tesnor}); - std::vector result(expected_output.size()); - output->read(result.data(), result.size() * sizeof(uint8_t)); + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int8_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_i8) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::i8; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int8_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_i8) +{ + const std::vector input{0xFE, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{-1, -2, 4, 3}; + const element::Type expected_output_type = ngraph::element::i8; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int8_t)); EXPECT_TRUE(test::all_close(expected_output, result)); } } -// destination: i8 NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i8) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 110, 128}; @@ -393,6 +594,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i8) } // destination: i16 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_i16) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::i16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_i16) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::i16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_i16) +{ + const std::vector input{0xFE, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{-1, -2, 4, 3}; + const element::Type expected_output_type = ngraph::element::i16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i16) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}; @@ -406,6 +679,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i16) } // destination: i32 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_i32) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::i32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_i32) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::i32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_i32) +{ + const std::vector input{0xFE, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{-1, -2, 4, 3}; + const element::Type expected_output_type = ngraph::element::i32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i32) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}; @@ -419,6 +764,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i32) } // destination: i64 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_i64) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::i64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_i64) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::i64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_i64) +{ + const std::vector input{0xFE, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{-1, -2, 4, 3}; + const element::Type expected_output_type = ngraph::element::i64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(int64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_i64) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}; @@ -468,6 +885,42 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u1) LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } +NGRAPH_TEST(${BACKEND_NAME}, convert_u16_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u16; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u32_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u32; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u64_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u64; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u1) { const std::vector input{0x10, 0x01, 0x00, 0x00}; @@ -480,6 +933,90 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u1) LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } +NGRAPH_TEST(${BACKEND_NAME}, convert_i8_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::i8; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i16_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::i16; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i32_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::i32; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i64_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::i64; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f16_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::f16; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_bf16_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::bf16; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f32_to_u1) +{ + const std::vector input{1, 0, 1, 0, 0, 0, 0, 1}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::f32; + + const std::vector expected_output{0xA1}; + const element::Type expected_output_type = ngraph::element::u1; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + // destination: u4 NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_u4) { @@ -505,7 +1042,6 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_u4) LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } - NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u4) { const std::vector input{7, 0, 1, 15}; @@ -518,6 +1054,42 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u4) LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } +NGRAPH_TEST(${BACKEND_NAME}, convert_u16_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u16; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u32_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u32; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u64_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u64; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u4) { const std::vector input{0x22, 0x33}; @@ -530,7 +1102,163 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u4) LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } +NGRAPH_TEST(${BACKEND_NAME}, convert_i8_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i8; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i16_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i16; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i32_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i32; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i64_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i64; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f16_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::f16; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_bf16_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::bf16; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_f32_to_u4) +{ + const std::vector input{7, 0, 1, 15}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::f32; + + const std::vector expected_output{0x70, 0x1F}; + const element::Type expected_output_type = ngraph::element::u4; + + LPConvertTest(input, input_shape, input_type, expected_output, expected_output_type); +} + // destination: u8 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_u8) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::u8; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint8_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_u8) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::u8; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint8_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u8) +{ + const std::vector input{0x12, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{1, 2, 4, 3}; + const element::Type expected_output_type = ngraph::element::u8; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint8_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u8) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 110, 127}; @@ -544,6 +1272,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u8) } // destination: u16 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_u16) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::u16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_u16) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::u16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u16) +{ + const std::vector input{0x12, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{1, 2, 4, 3}; + const element::Type expected_output_type = ngraph::element::u16; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint16_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u16) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 110, 127}; @@ -557,6 +1357,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u16) } // destination: u32 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_u32) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::u32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_u32) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::u32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u32) +{ + const std::vector input{0x12, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{1, 2, 4, 3}; + const element::Type expected_output_type = ngraph::element::u32; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint32_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u32) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 110, 127}; @@ -570,6 +1442,78 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u32) } // destination: u64 +NGRAPH_TEST(${BACKEND_NAME}, convert_u1_to_u64) +{ + const std::vector input{0x81}; + const Shape input_shape{8}; + const element::Type input_type = ngraph::element::u1; + + const std::vector expected_output{1, 0, 0, 0, 0, 0, 0, 1}; + const element::Type expected_output_type = ngraph::element::u64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_u4_to_u64) +{ + const std::vector input{0x21, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::u4; + + const std::vector expected_output{2, 1, 4, 3}; + const element::Type expected_output_type = ngraph::element::u64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + +NGRAPH_TEST(${BACKEND_NAME}, convert_i4_to_u64) +{ + const std::vector input{0x12, 0x43}; + const Shape input_shape{4}; + const element::Type input_type = ngraph::element::i4; + + const std::vector expected_output{1, 2, 4, 3}; + const element::Type expected_output_type = ngraph::element::u64; + + { + const auto f = CreateFunction(input_shape, input_type, expected_output_type); + auto backend = runtime::Backend::create("${BACKEND_NAME}"); + auto input_tesnor = backend->create_tensor(input_type, input_shape); + copy_data(input_tesnor, input); + auto output = backend->create_tensor(expected_output_type, input_shape); + auto handle = backend->compile(f); + handle->call_with_validate({output}, {input_tesnor}); + + std::vector result(expected_output.size()); + output->read(result.data(), result.size() * sizeof(uint64_t)); + EXPECT_TRUE(test::all_close(expected_output, result)); + } +} + NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u64) { const std::vector input{0, 10, 15, 20, 43, 56, 78, 99, 102, 110, 127}; @@ -582,6 +1526,7 @@ NGRAPH_TEST(${BACKEND_NAME}, convert_u8_to_u64) ConvertTest(input, input_shape, input_type, expected_output, expected_output_type); } +// jit tests NGRAPH_TEST(${BACKEND_NAME}, convert_float32_int8) { std::vector f32vec = {-100.5, -20.5, -15, -10.5, -0.5, 0, 0.5, 10.5, 15, 20.5, 100.5}; diff --git a/ngraph/test/runtime/ie/unit_test.manifest b/ngraph/test/runtime/ie/unit_test.manifest index dcb0b6cd288..8c4ae1f893d 100644 --- a/ngraph/test/runtime/ie/unit_test.manifest +++ b/ngraph/test/runtime/ie/unit_test.manifest @@ -1048,30 +1048,89 @@ roll_3d_input_negative_shift roll_negative_axes # convert operation -IE_CPU.convert_f16_to_f32 -IE_CPU.convert_u8_to_f16 -IE_CPU.convert_u8_to_i4 -IE_CPU.convert_u8_to_i16 -IE_CPU.convert_u8_to_i64 -IE_CPU.convert_u8_to_u1 -IE_CPU.convert_u8_to_u4 -IE_CPU.convert_u8_to_u16 -IE_CPU.convert_u8_to_u32 -IE_CPU.convert_u8_to_u64 IE_CPU.convert_u8_to_boolean IE_CPU.convert_i32_to_boolean IE_CPU.convert_f32_to_boolean -IE_CPU.convert_u32_to_f32 # NOT_IMPLEMENTED -IE_CPU.convert_i4_to_f32 # NOT_IMPLEMENTED -IE_CPU.convert_u1_to_f32 # NOT_IMPLEMENTED -IE_CPU.convert_u4_to_f32 # NOT_IMPLEMENTED +IE_CPU.convert_u8_to_f16 +IE_CPU.convert_u8_to_i16 +IE_CPU.convert_u8_to_i64 +IE_CPU.convert_u8_to_u16 +IE_CPU.convert_u8_to_u32 +IE_CPU.convert_u8_to_u64 +IE_CPU.convert_f16_to_f32 +IE_CPU.convert_u32_to_f32 +IE_CPU.convert_i4_to_f32 +IE_CPU.convert_u1_to_f32 +IE_CPU.convert_u4_to_f32 + IE_CPU.convert_u1_to_u1 IE_CPU.convert_u4_to_u1 +IE_CPU.convert_u8_to_u1 +IE_CPU.convert_u16_to_u1 +IE_CPU.convert_u32_to_u1 +IE_CPU.convert_u64_to_u1 IE_CPU.convert_i4_to_u1 +IE_CPU.convert_i8_to_u1 +IE_CPU.convert_i16_to_u1 +IE_CPU.convert_i32_to_u1 +IE_CPU.convert_i64_to_u1 +IE_CPU.convert_f16_to_u1 +IE_CPU.convert_bf16_to_u1 +IE_CPU.convert_f32_to_u1 + +IE_CPU.convert_u1_to_i4 +IE_CPU.convert_u4_to_i4 +IE_CPU.convert_u8_to_i4 +IE_CPU.convert_u16_to_i4 +IE_CPU.convert_u32_to_i4 +IE_CPU.convert_u64_to_i4 +IE_CPU.convert_i8_to_i4 +IE_CPU.convert_i16_to_i4 +IE_CPU.convert_i32_to_i4 +IE_CPU.convert_i64_to_i4 +IE_CPU.convert_f16_to_i4 +IE_CPU.convert_bf16_to_i4 +IE_CPU.convert_f32_to_i4 + IE_CPU.convert_u1_to_u4 IE_CPU.convert_u4_to_u4 +IE_CPU.convert_u8_to_u4 +IE_CPU.convert_u16_to_u4 +IE_CPU.convert_u32_to_u4 +IE_CPU.convert_u64_to_u4 IE_CPU.convert_i4_to_u4 +IE_CPU.convert_i8_to_u4 +IE_CPU.convert_i16_to_u4 +IE_CPU.convert_i32_to_u4 +IE_CPU.convert_i64_to_u4 +IE_CPU.convert_f16_to_u4 +IE_CPU.convert_bf16_to_u4 +IE_CPU.convert_f32_to_u4 +IE_CPU.convert_u1_to_i8 +IE_CPU.convert_u4_to_i8 +IE_CPU.convert_i4_to_i8 +IE_CPU.convert_u1_to_i16 +IE_CPU.convert_u4_to_i16 +IE_CPU.convert_i4_to_i16 +IE_CPU.convert_u1_to_i32 +IE_CPU.convert_u4_to_i32 +IE_CPU.convert_i4_to_i32 +IE_CPU.convert_u1_to_i64 +IE_CPU.convert_u4_to_i64 +IE_CPU.convert_i4_to_i64 +IE_CPU.convert_u1_to_u8 +IE_CPU.convert_u4_to_u8 +IE_CPU.convert_i4_to_u8 +IE_CPU.convert_u1_to_u16 +IE_CPU.convert_u4_to_u16 +IE_CPU.convert_i4_to_u16 +IE_CPU.convert_u1_to_u32 +IE_CPU.convert_u4_to_u32 +IE_CPU.convert_i4_to_u32 +IE_CPU.convert_u1_to_u64 +IE_CPU.convert_u4_to_u64 +IE_CPU.convert_i4_to_u64 #------------------------------------------------------------------------------- # # Inference Engine CPU plugin excludes diff --git a/ngraph/test/runtime/interpreter/evaluates_map.cpp b/ngraph/test/runtime/interpreter/evaluates_map.cpp index 2843fa88a32..b737d94e021 100644 --- a/ngraph/test/runtime/interpreter/evaluates_map.cpp +++ b/ngraph/test/runtime/interpreter/evaluates_map.cpp @@ -1489,72 +1489,6 @@ namespace return true; } - namespace convert_v0 - { - template - inline void evaluate(const shared_ptr& op, - const HostTensorVector& outputs, - const HostTensorVector& inputs) - { - using TI = typename element_type_traits::value_type; - using TO = typename element_type_traits::value_type; - runtime::reference::convert(inputs[0]->get_data_ptr(), - outputs[0]->get_data_ptr(), - shape_size(inputs[0]->get_shape())); - } - } // namespace convert_v0 - - template - bool evaluate(const shared_ptr& op, - const HostTensorVector& outputs, - const HostTensorVector& inputs) - { - switch (inputs[0]->get_element_type()) - { - case element::Type_t::boolean: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::i8: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::i16: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::i32: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::i64: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::u8: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::u16: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::u32: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::u64: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::f16: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::f32: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::f64: - convert_v0::evaluate(op, outputs, inputs); - break; - case element::Type_t::bf16: - convert_v0::evaluate(op, outputs, inputs); - break; - default: return false; - } - return true; - } - namespace convert_like_v1 { template