Merge branch 4.x

modules/gapi/test/infer/gapi_infer_ie_test.cpp

@@ -2,7 +2,7 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html.
 //
-// Copyright (C) 2019-2021 Intel Corporation
+// Copyright (C) 2019-2023 Intel Corporation
 
 #include "../test_precomp.hpp"
 
@@ -2238,7 +2238,7 @@ TEST(TestAgeGenderIE, InferWithBatch)
     params.weights_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
     params.device_id = "CPU";
 
-    cv::Mat in_mat({batch_size, 3, 320, 240}, CV_8U);
+    cv::Mat in_mat({batch_size, 3, 62, 62}, CV_8U);
     cv::randu(in_mat, 0, 255);
 
     cv::Mat gapi_age, gapi_gender;
@@ -2247,8 +2247,9 @@ TEST(TestAgeGenderIE, InferWithBatch)
     IE::Blob::Ptr ie_age, ie_gender;
     {
         auto plugin = cv::gimpl::ie::wrap::getPlugin(params);
-        auto net    = cv::gimpl::ie::wrap::readNetwork(params);
-        setNetParameters(net);
+        auto net = cv::gimpl::ie::wrap::readNetwork(params);
+        auto ii = net.getInputsInfo().at("data");
+        ii->setPrecision(IE::Precision::U8);
         net.setBatchSize(batch_size);
         auto this_network  = cv::gimpl::ie::wrap::loadNetwork(plugin, net, params);
         auto infer_request = this_network.CreateInferRequest();
@@ -3056,6 +3057,73 @@ TEST_F(AgeGenderInferTest, ChangeSpecificOutputPrecison) {
     validate();
 }
 
+TEST_F(AgeGenderInferTest, ThrowIfSetLayoutForImage) {
+    auto pp = cv::gapi::ie::Params<AgeGender> {
+        m_params.model_path, m_params.weights_path, m_params.device_id
+    }.cfgOutputLayers({ "age_conv3", "prob" })
+     .cfgOutputPrecision({{"prob", CV_8U}})
+     .cfgInputLayout("NHWC");
+
+    EXPECT_ANY_THROW(buildGraph().apply(cv::gin(m_in_mat), cv::gout(m_gapi_age, m_gapi_gender),
+                                        cv::compile_args(cv::gapi::networks(pp))));
+}
+
+TEST(TestAgeGenderIE, InferTensorWithPreproc) {
+    initDLDTDataPath();
+
+    cv::gapi::ie::detail::ParamDesc params;
+    params.model_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    params.weights_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    params.device_id = "CPU";
+
+    // Load IE network, initialize input data using that.
+    cv::Mat in_mat({1, 240, 320, 3}, CV_8U);
+    cv::randu(in_mat, 0, 255);
+    cv::Mat gapi_age, gapi_gender;
+
+    IE::Blob::Ptr ie_age, ie_gender;
+    {
+        auto plugin        = cv::gimpl::ie::wrap::getPlugin(params);
+        auto net           = cv::gimpl::ie::wrap::readNetwork(params);
+        auto ii = net.getInputsInfo().at("data");
+
+        ii->setPrecision(IE::Precision::U8);
+        ii->getPreProcess().setResizeAlgorithm(IE::RESIZE_BILINEAR);
+        ii->setLayout(IE::Layout::NHWC);
+
+        auto this_network  = cv::gimpl::ie::wrap::loadNetwork(plugin, net, params);
+        auto infer_request = this_network.CreateInferRequest();
+        IE::TensorDesc desc{IE::Precision::U8, {1, 3, 240, 320}, IE::Layout::NHWC};
+        auto blob =  IE::make_shared_blob<uint8_t>(desc, const_cast<uint8_t*>(in_mat.ptr<uint8_t>()));
+        infer_request.SetBlob("data", blob);
+        infer_request.Infer();
+        ie_age    = infer_request.GetBlob("age_conv3");
+        ie_gender = infer_request.GetBlob("prob");
+    }
+
+    // Configure & run G-API
+    using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+    G_API_NET(AgeGender, <AGInfo(cv::GMat)>, "test-age-gender");
+
+    cv::GMat in;
+    cv::GMat age, gender;
+    std::tie(age, gender) = cv::gapi::infer<AgeGender>(in);
+    cv::GComputation comp(cv::GIn(in), cv::GOut(age, gender));
+
+    auto pp = cv::gapi::ie::Params<AgeGender> {
+        params.model_path, params.weights_path, params.device_id
+    }.cfgOutputLayers({ "age_conv3", "prob" })
+     .cfgResize(cv::INTER_LINEAR)
+     .cfgInputLayout("NHWC");
+
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Validate with IE itself (avoid DNN module dependency here)
+    normAssert(cv::gapi::ie::util::to_ocv(ie_age),    gapi_age,    "Test age output"   );
+    normAssert(cv::gapi::ie::util::to_ocv(ie_gender), gapi_gender, "Test gender output");
+}
+
 } // namespace opencv_test
 
 #endif //  HAVE_INF_ENGINE

modules/gapi/test/infer/gapi_infer_ov_tests.cpp

@@ -0,0 +1,540 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+//
+// Copyright (C) 2023 Intel Corporation
+
+#if defined HAVE_INF_ENGINE && INF_ENGINE_RELEASE >= 2022010000
+
+#include "../test_precomp.hpp"
+
+#include "backends/ov/util.hpp"
+
+#include <opencv2/gapi/infer/ov.hpp>
+
+#include <openvino/openvino.hpp>
+
+namespace opencv_test
+{
+
+namespace {
+// FIXME: taken from DNN module
+void initDLDTDataPath()
+{
+#ifndef WINRT
+    static bool initialized = false;
+    if (!initialized)
+    {
+        const char* omzDataPath = getenv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
+        if (omzDataPath)
+            cvtest::addDataSearchPath(omzDataPath);
+        const char* dnnDataPath = getenv("OPENCV_DNN_TEST_DATA_PATH");
+        if (dnnDataPath) {
+            // Add the dnnDataPath itself - G-API is using some images there directly
+            cvtest::addDataSearchPath(dnnDataPath);
+            cvtest::addDataSearchPath(dnnDataPath + std::string("/omz_intel_models"));
+        }
+        initialized = true;
+    }
+#endif // WINRT
+}
+
+static const std::string SUBDIR = "intel/age-gender-recognition-retail-0013/FP32/";
+
+void copyFromOV(ov::Tensor &tensor, cv::Mat &mat) {
+    GAPI_Assert(tensor.get_byte_size() == mat.total() * mat.elemSize());
+    std::copy_n(reinterpret_cast<uint8_t*>(tensor.data()),
+                tensor.get_byte_size(),
+                mat.ptr<uint8_t>());
+}
+
+void copyToOV(const cv::Mat &mat, ov::Tensor &tensor) {
+    GAPI_Assert(tensor.get_byte_size() == mat.total() * mat.elemSize());
+    std::copy_n(mat.ptr<uint8_t>(),
+                tensor.get_byte_size(),
+                reinterpret_cast<uint8_t*>(tensor.data()));
+}
+
+// FIXME: taken from the DNN module
+void normAssert(cv::InputArray ref, cv::InputArray test,
+                const char *comment /*= ""*/,
+                double l1 = 0.00001, double lInf = 0.0001) {
+    double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total();
+    EXPECT_LE(normL1, l1) << comment;
+
+    double normInf = cvtest::norm(ref, test, cv::NORM_INF);
+    EXPECT_LE(normInf, lInf) << comment;
+}
+
+ov::Core getCore() {
+    static ov::Core core;
+    return core;
+}
+
+// TODO: AGNetGenComp, AGNetTypedComp, AGNetOVComp, AGNetOVCompiled
+// can be generalized to work with any model and used as parameters for tests.
+
+struct AGNetGenComp {
+    static constexpr const char* tag = "age-gender-generic";
+    using Params = cv::gapi::ov::Params<cv::gapi::Generic>;
+
+    static Params params(const std::string &xml,
+                         const std::string &bin,
+                         const std::string &device) {
+        return {tag, xml, bin, device};
+    }
+
+    static Params params(const std::string &blob_path,
+                         const std::string &device) {
+        return {tag, blob_path, device};
+    }
+
+    static cv::GComputation create() {
+        cv::GMat in;
+        GInferInputs inputs;
+        inputs["data"] = in;
+        auto outputs = cv::gapi::infer<cv::gapi::Generic>(tag, inputs);
+        auto age = outputs.at("age_conv3");
+        auto gender = outputs.at("prob");
+        return cv::GComputation{cv::GIn(in), cv::GOut(age, gender)};
+    }
+};
+
+struct AGNetTypedComp {
+    using AGInfo = std::tuple<cv::GMat, cv::GMat>;
+    G_API_NET(AgeGender, <AGInfo(cv::GMat)>, "typed-age-gender");
+    using Params = cv::gapi::ov::Params<AgeGender>;
+
+    static Params params(const std::string &xml_path,
+                         const std::string &bin_path,
+                         const std::string &device) {
+        return Params {
+            xml_path, bin_path, device
+        }.cfgOutputLayers({ "age_conv3", "prob" });
+    }
+
+    static cv::GComputation create() {
+        cv::GMat in;
+        cv::GMat age, gender;
+        std::tie(age, gender) = cv::gapi::infer<AgeGender>(in);
+        return cv::GComputation{cv::GIn(in), cv::GOut(age, gender)};
+    }
+};
+
+class AGNetOVCompiled {
+public:
+    AGNetOVCompiled(ov::CompiledModel &&compiled_model)
+        : m_compiled_model(std::move(compiled_model)) {
+    }
+
+    void operator()(const cv::Mat &in_mat,
+                          cv::Mat &age_mat,
+                          cv::Mat &gender_mat) {
+        auto infer_request = m_compiled_model.create_infer_request();
+        auto input_tensor   = infer_request.get_input_tensor();
+        copyToOV(in_mat, input_tensor);
+
+        infer_request.infer();
+
+        auto age_tensor = infer_request.get_tensor("age_conv3");
+        age_mat.create(cv::gapi::ov::util::to_ocv(age_tensor.get_shape()),
+                       cv::gapi::ov::util::to_ocv(age_tensor.get_element_type()));
+        copyFromOV(age_tensor, age_mat);
+
+        auto gender_tensor = infer_request.get_tensor("prob");
+        gender_mat.create(cv::gapi::ov::util::to_ocv(gender_tensor.get_shape()),
+                          cv::gapi::ov::util::to_ocv(gender_tensor.get_element_type()));
+        copyFromOV(gender_tensor, gender_mat);
+    }
+
+    void export_model(const std::string &outpath) {
+        std::ofstream file{outpath, std::ios::out | std::ios::binary};
+        GAPI_Assert(file.is_open());
+        m_compiled_model.export_model(file);
+    }
+
+private:
+    ov::CompiledModel m_compiled_model;
+};
+
+struct ImageInputPreproc {
+    void operator()(ov::preprocess::PrePostProcessor &ppp) {
+        ppp.input().tensor().set_layout(ov::Layout("NHWC"))
+                            .set_element_type(ov::element::u8)
+                            .set_shape({1, size.height, size.width, 3});
+        ppp.input().model().set_layout(ov::Layout("NCHW"));
+        ppp.input().preprocess().resize(::ov::preprocess::ResizeAlgorithm::RESIZE_LINEAR);
+    }
+
+    cv::Size size;
+};
+
+class AGNetOVComp {
+public:
+    AGNetOVComp(const std::string &xml_path,
+                const std::string &bin_path,
+                const std::string &device)
+        : m_device(device) {
+        m_model = getCore().read_model(xml_path, bin_path);
+    }
+
+    using PrePostProcessF = std::function<void(ov::preprocess::PrePostProcessor&)>;
+
+    void cfgPrePostProcessing(PrePostProcessF f) {
+        ov::preprocess::PrePostProcessor ppp(m_model);
+        f(ppp);
+        m_model = ppp.build();
+    }
+
+    AGNetOVCompiled compile() {
+        auto compiled_model = getCore().compile_model(m_model, m_device);
+        return {std::move(compiled_model)};
+    }
+
+    void apply(const cv::Mat &in_mat,
+                     cv::Mat &age_mat,
+                     cv::Mat &gender_mat) {
+        compile()(in_mat, age_mat, gender_mat);
+    }
+
+private:
+    std::string m_device;
+    std::shared_ptr<ov::Model> m_model;
+};
+
+} // anonymous namespace
+
+// TODO: Make all of tests below parmetrized to avoid code duplication
+TEST(TestAgeGenderOV, InferTypedTensor) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 3, 62, 62}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetTypedComp::create();
+    auto pp   = AGNetTypedComp::params(xml_path, bin_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferTypedImage) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat(300, 300, CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing(ImageInputPreproc{in_mat.size()});
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetTypedComp::create();
+    auto pp   = AGNetTypedComp::params(xml_path, bin_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferGenericTensor) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 3, 62, 62}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(xml_path, bin_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferGenericImage) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat(300, 300, CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing(ImageInputPreproc{in_mat.size()});
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(xml_path, bin_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferGenericImageBlob) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string blob_path = "age-gender-recognition-retail-0013.blob";
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat(300, 300, CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing(ImageInputPreproc{in_mat.size()});
+    auto cc_ref = ref.compile();
+    // NB: Output blob will contain preprocessing inside.
+    cc_ref.export_model(blob_path);
+    cc_ref(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(blob_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferGenericTensorBlob) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string blob_path = "age-gender-recognition-retail-0013.blob";
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 3, 62, 62}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    auto cc_ref = ref.compile();
+    cc_ref.export_model(blob_path);
+    cc_ref(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(blob_path, device);
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferBothOutputsFP16) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 3, 62, 62}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing([](ov::preprocess::PrePostProcessor &ppp){
+        ppp.output(0).tensor().set_element_type(ov::element::f16);
+        ppp.output(1).tensor().set_element_type(ov::element::f16);
+    });
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(xml_path, bin_path, device);
+    pp.cfgOutputTensorPrecision(CV_16F);
+
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, InferOneOutputFP16) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 3, 62, 62}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    const std::string fp16_output_name = "prob";
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing([&](ov::preprocess::PrePostProcessor &ppp){
+        ppp.output(fp16_output_name).tensor().set_element_type(ov::element::f16);
+    });
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(xml_path, bin_path, device);
+    pp.cfgOutputTensorPrecision({{fp16_output_name, CV_16F}});
+
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+TEST(TestAgeGenderOV, ThrowCfgOutputPrecForBlob) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string blob_path = "age-gender-recognition-retail-0013.blob";
+    const std::string device   = "CPU";
+
+    // OpenVINO (Just for blob compilation)
+    AGNetOVComp ref(xml_path, bin_path, device);
+    auto cc_ref = ref.compile();
+    cc_ref.export_model(blob_path);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(blob_path, device);
+
+    EXPECT_ANY_THROW(pp.cfgOutputTensorPrecision(CV_16F));
+}
+
+TEST(TestAgeGenderOV, ThrowInvalidConfigIR) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(xml_path, bin_path, device);
+    pp.cfgPluginConfig({{"some_key", "some_value"}});
+
+    EXPECT_ANY_THROW(comp.compile(cv::GMatDesc{CV_8U,3,cv::Size{320, 240}},
+                                  cv::compile_args(cv::gapi::networks(pp))));
+}
+
+TEST(TestAgeGenderOV, ThrowInvalidConfigBlob) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string blob_path = "age-gender-recognition-retail-0013.blob";
+    const std::string device   = "CPU";
+
+    // OpenVINO (Just for blob compilation)
+    AGNetOVComp ref(xml_path, bin_path, device);
+    auto cc_ref = ref.compile();
+    cc_ref.export_model(blob_path);
+
+    // G-API
+    auto comp = AGNetGenComp::create();
+    auto pp   = AGNetGenComp::params(blob_path, device);
+    pp.cfgPluginConfig({{"some_key", "some_value"}});
+
+    EXPECT_ANY_THROW(comp.compile(cv::GMatDesc{CV_8U,3,cv::Size{320, 240}},
+                                  cv::compile_args(cv::gapi::networks(pp))));
+}
+
+TEST(TestAgeGenderOV, ThrowInvalidImageLayout) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    // NB: This mat may only have "NHWC" layout.
+    cv::Mat in_mat(300, 300, CV_8UC3);
+    cv::randu(in_mat, 0, 255);
+    cv::Mat gender, gapi_age, gapi_gender;
+    auto comp = AGNetTypedComp::create();
+    auto pp = AGNetTypedComp::params(xml_path, bin_path, device);
+
+    pp.cfgInputTensorLayout("NCHW");
+
+    EXPECT_ANY_THROW(comp.compile(cv::descr_of(in_mat),
+                     cv::compile_args(cv::gapi::networks(pp))));
+}
+
+TEST(TestAgeGenderOV, InferTensorWithPreproc) {
+    initDLDTDataPath();
+    const std::string xml_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.xml");
+    const std::string bin_path = findDataFile(SUBDIR + "age-gender-recognition-retail-0013.bin");
+    const std::string device   = "CPU";
+
+    cv::Mat in_mat({1, 240, 320, 3}, CV_32F);
+    cv::randu(in_mat, -1, 1);
+    cv::Mat ov_age, ov_gender, gapi_age, gapi_gender;
+
+    // OpenVINO
+    AGNetOVComp ref(xml_path, bin_path, device);
+    ref.cfgPrePostProcessing([](ov::preprocess::PrePostProcessor &ppp) {
+        auto& input = ppp.input();
+        input.tensor().set_spatial_static_shape(240, 320)
+                      .set_layout("NHWC");
+        input.preprocess().resize(ov::preprocess::ResizeAlgorithm::RESIZE_LINEAR);
+    });
+    ref.apply(in_mat, ov_age, ov_gender);
+
+    // G-API
+    auto comp = AGNetTypedComp::create();
+    auto pp = AGNetTypedComp::params(xml_path, bin_path, device);
+    pp.cfgResize(cv::INTER_LINEAR)
+      .cfgInputTensorLayout("NHWC");
+
+    comp.apply(cv::gin(in_mat), cv::gout(gapi_age, gapi_gender),
+               cv::compile_args(cv::gapi::networks(pp)));
+
+    // Assert
+    normAssert(ov_age,    gapi_age,    "Test age output"   );
+    normAssert(ov_gender, gapi_gender, "Test gender output");
+}
+
+} // namespace opencv_test
+
+#endif // HAVE_INF_ENGINE && INF_ENGINE_RELEASE >= 2022010000