third_party/opencv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #18902 from mpashchenkov:mp/onnx-const-input

Browse Source 
G-API: ONNX. Const input

* Added const input for ONNX backend

* Returned initMatrixRandu, added some comments, rebase
This commit is contained in:
Maxim Pashchenkov
2021-01-13 00:31:15 +03:00
committed by GitHub
parent d3bc563c6e
commit 3eaeca58da
3 changed files with 315 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/src/backends/ie/giebackend.cpp
-8
View File
@@ -263,14 +263,6 @@ struct IEUnit {
// Still, constant data is to set only once.
this_request.SetBlob(p.first, wrapIE(p.second.first, p.second.second));
}
// Bind const data to infer request
for (auto &&p : params.const_inputs) {
// FIXME: SetBlob is known to be inefficient,
// it is worth to make a customizable "initializer" and pass the
// cv::Mat-wrapped blob there to support IE's optimal "GetBlob idiom"
// Still, constant data is to set only once.
this_request.SetBlob(p.first, wrapIE(p.second.first, p.second.second));
}
return {this_plugin, this_network, this_request};
}
modules/gapi/src/backends/onnx/gonnxbackend.cpp
+64 -11
View File
@@ -16,6 +16,7 @@
#include <opencv2/gapi/gframe.hpp>
#include "api/gbackend_priv.hpp" // FIXME: Make it part of Backend SDK!
#include "logger.hpp"
namespace {
struct ONNXCallContext;
@@ -30,12 +31,35 @@ enum TensorPosition : int {
OUTPUT
};
static std::string pdims(const std::vector<int64_t> &dims) {
std::stringstream ss;
auto it = dims.begin();
ss << *it++;
for (; it != dims.end(); ++it) {
ss << '/' << *it;
}
return ss.str();
}
struct TensorInfo {
TensorInfo() = default;
explicit TensorInfo(const Ort::TensorTypeAndShapeInfo& info)
: dims(info.GetShape())
, type(info.GetElementType())
, is_dynamic(std::find(dims.begin(), dims.end(), -1) != dims.end()) {
// Double-check if the tensor is really dynamic
// Allow N to be -1
if (is_dynamic
&& dims[0] == -1
&& dims.size() > 1
&& std::find(dims.begin() + 1, dims.end(), -1) == dims.end()) {
GAPI_LOG_WARNING(NULL, "Promoting N=-1 to N=1 for tensor " << pdims(dims));
dims[0] = 1;
is_dynamic = false;
}
if (!is_dynamic) {
size = std::accumulate(dims.begin(),
dims.end(),
@@ -81,6 +105,7 @@ class ONNXCompiled {
std::vector<TensorInfo> in_tensor_info;
std::vector<TensorInfo> out_tensor_info;
bool is_dynamic = false;
bool is_postproc = false;
// G-API <Net> description
gapi::onnx::detail::ParamDesc params;
@@ -95,6 +120,7 @@ class ONNXCompiled {
void Run(const std::vector<cv::Mat>& ins,
const std::vector<cv::Mat>& outs);
std::vector<std::string> in_names_without_const;
public:
explicit ONNXCompiled(const gapi::onnx::detail::ParamDesc &pp);
@@ -142,6 +168,7 @@ inline int toCV(ONNXTensorElementDataType prec) {
switch (prec) {
case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8: return CV_8U;
case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT: return CV_32F;
case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32: return CV_32S;
default: GAPI_Assert(false && "Unsupported data type");
}
return -1;
@@ -308,6 +335,8 @@ inline Ort::Value createTensor(const Ort::MemoryInfo& memory_info,
return createTensor<uint8_t>(memory_info, tensor_params, data);
case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT:
return createTensor<float>(memory_info, tensor_params, data);
case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32:
return createTensor<int32_t>(memory_info, tensor_params, data);
default:
GAPI_Assert(false && "Unsupported data type");
}
@@ -523,7 +552,6 @@ namespace onnx {
ONNXCompiled::ONNXCompiled(const gapi::onnx::detail::ParamDesc &pp)
: params(pp) {
// Validate input parameters before allocating any resources
if (params.num_in > 1u && params.num_in != params.input_names.size()) {
cv::util::throw_error(std::logic_error("Please specify input layer names for "
@@ -553,6 +581,7 @@ ONNXCompiled::ONNXCompiled(const gapi::onnx::detail::ParamDesc &pp)
"Please provide a custom post-processing function "
"(.cfgPostProc) in network parameters"));
}
is_postproc = (params.custom_post_proc != nullptr);
// Update parameters based on session information
if (params.num_in == 1u && params.input_names.empty()) {
@@ -563,8 +592,6 @@ ONNXCompiled::ONNXCompiled(const gapi::onnx::detail::ParamDesc &pp)
}
// Validate what is supported currently
GAPI_Assert(params.const_inputs.empty()
&& "Const inputs are not currently supported");
GAPI_Assert(std::all_of(in_tensor_info.begin(),
in_tensor_info.end(),
[](const cv::gimpl::onnx::TensorInfo &p) {
@@ -593,6 +620,17 @@ ONNXCompiled::ONNXCompiled(const gapi::onnx::detail::ParamDesc &pp)
}
}
if (!params.const_inputs.empty()) {
// Form input names order without const input names
in_names_without_const.clear();
std::copy_if(params.input_names.begin(), params.input_names.end(),
std::back_inserter(in_names_without_const),
[&](const std::string& name) {
const auto it = params.const_inputs.find(name);
return it == params.const_inputs.end();
});
}
// Pre-allocate vectors (not buffers) for runtime info
in_data.resize(params.num_in);
out_data.resize(params.num_out);
@@ -626,9 +664,9 @@ std::vector<TensorInfo> ONNXCompiled::getTensorInfo(TensorPosition pos) {
}
cv::GMatDesc ONNXCompiled::outMeta(int idx) const {
if (is_dynamic) {
if (is_dynamic || is_postproc) {
GAPI_Assert(!params.out_metas.empty()
&& "Metadata must be specified if NN has dynamic inputs!");
&& "Metadata must be specified if NN has dynamic inputs or post-processing function is used!");
return params.out_metas.at(idx);
}
const auto ort_idx = getIdxByName(out_tensor_info, params.output_names[idx]);
@@ -678,9 +716,12 @@ void ONNXCompiled::Run(const std::vector<cv::Mat>& ins,
const std::vector<cv::Mat>& outs) {
std::vector<Ort::Value> in_tensors, out_tensors;
auto in_run_names = getCharNames(params.input_names);
for (const auto it : ade::util::indexed(params.input_names)) {
// Layer names order for run
auto input_names = (in_names_without_const.empty() && params.const_inputs.empty())
? params.input_names
: in_names_without_const;
// Creates tensors for unique names that don't contain constant input
for (const auto it : ade::util::indexed(input_names)) {
auto i = ade::util::index(it);
auto in_name = ade::util::value(it);
const auto idx = getIdxByName(in_tensor_info, in_name);
@@ -689,7 +730,19 @@ void ONNXCompiled::Run(const std::vector<cv::Mat>& ins,
ins[i]));
}
if (!is_dynamic) {
for (auto &&c_in_pair : params.const_inputs) {
const auto idx = getIdxByName(in_tensor_info, c_in_pair.first);
in_tensors.emplace_back(createTensor(this_memory_info,
in_tensor_info[idx],
c_in_pair.second.first));
// Puts const input names in sequence for Run
// ONNXRuntime can match input tensors to CNN inputs by names
input_names.emplace_back(c_in_pair.first);
}
GAPI_Assert(input_names.size() == this_session.GetInputCount());
auto in_run_names = getCharNames(input_names);
if (!is_dynamic && !is_postproc) {
// Easy path - just run the session which is bound to G-API's
// internal data
for (auto i : ade::util::iota(params.output_names.size())) {
@@ -701,7 +754,7 @@ void ONNXCompiled::Run(const std::vector<cv::Mat>& ins,
this_session.Run(Ort::RunOptions{nullptr},
in_run_names.data(),
&in_tensors.front(),
params.input_names.size(),
input_names.size(),
out_run_names.data(),
&out_tensors.front(),
params.output_names.size());
@@ -716,7 +769,7 @@ void ONNXCompiled::Run(const std::vector<cv::Mat>& ins,
auto outputs = this_session.Run(Ort::RunOptions{nullptr},
in_run_names.data(),
&in_tensors.front(),
params.input_names.size(),
input_names.size(),
out_names.data(),
out_names.size());
std::unordered_map<std::string, cv::Mat> onnx_outputs;
modules/gapi/test/infer/gapi_infer_onnx_test.cpp
+251 -73
View File
@@ -81,8 +81,24 @@ cv::Mat initMatrixRandU(const int type, const cv::Size& sz_in) {
namespace opencv_test
{
namespace {
void initTestDataPath()
{
#ifndef WINRT
static bool initialized = false;
if (!initialized)
{
// Since G-API has no own test data (yet), it is taken from the common space
const char* testDataPath = getenv("OPENCV_TEST_DATA_PATH");
if (testDataPath) {
cvtest::addDataSearchPath(testDataPath);
}
initialized = true;
}
#endif // WINRT
}
// FIXME: taken from the DNN module
void normAssert(const cv::InputArray& ref, const cv::InputArray& test,
void normAssert(cv::InputArray& ref, cv::InputArray& test,
const char *comment /*= ""*/,
const double l1 = 0.00001, const double lInf = 0.0001) {
const double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total();
@@ -109,6 +125,7 @@ inline int toCV(const ONNXTensorElementDataType prec) {
switch (prec) {
case ONNX_TENSOR_ELEMENT_DATA_TYPE_UINT8: return CV_8U;
case ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT: return CV_32F;
case ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32: return CV_32S;
default: GAPI_Assert(false && "Unsupported data type");
}
return -1;
@@ -126,46 +143,97 @@ inline std::vector<const char*> getCharNames(const std::vector<std::string>& nam
return out_vec;
}
inline void copyToOut(const cv::Mat& in, cv::Mat& out) {
GAPI_Assert(in.depth() == CV_32F);
GAPI_Assert(in.size == out.size);
const float* const inptr = in.ptr<float>();
float* const optr = out.ptr<float>();
const int size = in.total();
for (int i = 0; i < size; ++i) {
optr[i] = inptr[i];
template<typename T>
void copyToOut(const cv::Mat& in, cv::Mat& out) {
const size_t size = std::min(out.total(), in.total());
std::copy(in.begin<T>(), in.begin<T>() + size, out.begin<T>());
if (size < out.total()) {
T* const optr = out.ptr<T>();
optr[size] = static_cast<T>(-1); // end data mark
}
}
void remapYolo(const std::unordered_map<std::string, cv::Mat> &onnx,
std::unordered_map<std::string, cv::Mat> &gapi) {
std::unordered_map<std::string, cv::Mat> &gapi) {
GAPI_Assert(onnx.size() == 1u);
GAPI_Assert(gapi.size() == 1u);
// Result from Run method
const cv::Mat& in = onnx.begin()->second;
GAPI_Assert(in.depth() == CV_32F);
// Configured output
cv::Mat& out = gapi.begin()->second;
// Simple copy
copyToOut(in, out);
copyToOut<float>(in, out);
}
void remapSsdPorts(const std::unordered_map<std::string, cv::Mat> &onnx,
std::unordered_map<std::string, cv::Mat> &gapi) {
// Result from Run method
const cv::Mat& in_num = onnx.at("num_detections:0");
const cv::Mat& in_boxes = onnx.at("detection_boxes:0");
const cv::Mat& in_scores = onnx.at("detection_scores:0");
const cv::Mat& in_classes = onnx.at("detection_classes:0");
// Configured outputs
cv::Mat& out_boxes = gapi.at("out1");
cv::Mat& out_classes = gapi.at("out2");
cv::Mat& out_scores = gapi.at("out3");
cv::Mat& out_num = gapi.at("out4");
void remapYoloV3(const std::unordered_map<std::string, cv::Mat> &onnx,
std::unordered_map<std::string, cv::Mat> &gapi) {
// Simple copy for outputs
copyToOut(in_num, out_num);
copyToOut(in_boxes, out_boxes);
copyToOut(in_scores, out_scores);
copyToOut(in_classes, out_classes);
const cv::Mat& in_boxes = onnx.at("yolonms_layer_1/ExpandDims_1:0");
const cv::Mat& in_scores = onnx.at("yolonms_layer_1/ExpandDims_3:0");
const cv::Mat& in_indices = onnx.at("yolonms_layer_1/concat_2:0");
GAPI_Assert(in_boxes.depth() == CV_32F);
GAPI_Assert(in_scores.depth() == CV_32F);
GAPI_Assert(in_indices.depth() == CV_32S);
cv::Mat& out_boxes = gapi.at("out1");
cv::Mat& out_scores = gapi.at("out2");
cv::Mat& out_indices = gapi.at("out3");
copyToOut<float>(in_boxes, out_boxes);
copyToOut<float>(in_scores, out_scores);
copyToOut<int32_t>(in_indices, out_indices);
}
void remapToIESSDOut(const std::vector<cv::Mat> &detections,
cv::Mat &ssd_output) {
for (const auto &det_el : detections) {
GAPI_Assert(det_el.depth() == CV_32F);
GAPI_Assert(!det_el.empty());
}
// SSD-MobilenetV1 structure check
ASSERT_EQ(detections[0].total(), 1u);
ASSERT_EQ(detections[2].total(), detections[0].total() * 100);
ASSERT_EQ(detections[2].total(), detections[3].total());
ASSERT_EQ((detections[2].total() * 4), detections[1].total());
const int num_objects = static_cast<int>(detections[0].ptr<float>()[0]);
GAPI_Assert(num_objects <= (ssd_output.size[2] - 1));
const float *in_boxes = detections[1].ptr<float>();
const float *in_scores = detections[2].ptr<float>();
const float *in_classes = detections[3].ptr<float>();
float *ptr = ssd_output.ptr<float>();
for (int i = 0; i < num_objects; i++) {
ptr[0] = 0.f; // "image_id"
ptr[1] = in_classes[i]; // "label"
ptr[2] = in_scores[i]; // "confidence"
ptr[3] = in_boxes[4 * i + 1]; // left
ptr[4] = in_boxes[4 * i + 0]; // top
ptr[5] = in_boxes[4 * i + 3]; // right
ptr[6] = in_boxes[4 * i + 2]; // bottom
ptr += 7;
in_boxes += 4;
}
if (num_objects < ssd_output.size[2] - 1) {
// put a -1 mark at the end of output blob if there is space left
ptr[0] = -1.f;
}
}
void remapSSDPorts(const std::unordered_map<std::string, cv::Mat> &onnx,
std::unordered_map<std::string, cv::Mat> &gapi) {
// Assemble ONNX-processed outputs back to a single 1x1x200x7 blob
// to preserve compatibility with OpenVINO-based SSD pipeline
const cv::Mat &num_detections = onnx.at("num_detections:0");
const cv::Mat &detection_boxes = onnx.at("detection_boxes:0");
const cv::Mat &detection_scores = onnx.at("detection_scores:0");
const cv::Mat &detection_classes = onnx.at("detection_classes:0");
cv::Mat &ssd_output = gapi.at("detection_output");
remapToIESSDOut({num_detections, detection_boxes, detection_scores, detection_classes}, ssd_output);
}
class ONNXtest : public ::testing::Test {
@@ -177,18 +245,17 @@ public:
cv::Mat in_mat1;
ONNXtest() {
initTestDataPath();
env = Ort::Env(ORT_LOGGING_LEVEL_WARNING, "test");
memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
out_gapi.resize(1);
out_onnx.resize(1);
// FIXME: All tests chek "random" image
// Ideally it should be a real image
in_mat1 = initMatrixRandU(CV_8UC3, cv::Size{640, 480});
// FIXME: It should be an image from own (gapi) directory in opencv extra
in_mat1 = cv::imread(findDataFile("cv/dpm/cat.png"));
}
template<typename T>
void infer(const std::vector<cv::Mat>& ins,
std::vector<cv::Mat>& outs) {
void infer(const std::vector<cv::Mat>& ins, std::vector<cv::Mat>& outs) {
// Prepare session
session = Ort::Session(env, model_path.data(), session_options);
num_in = session.GetInputCount();
@@ -241,10 +308,15 @@ public:
template<typename T>
void infer(const cv::Mat& in, cv::Mat& out) {
std::vector<cv::Mat> result;
infer<T>({in}, result);
infer<T>(std::vector<cv::Mat>{in}, result);
GAPI_Assert(result.size() == 1u);
out = result.front();
}
// One input overload
template<typename T>
void infer(const cv::Mat& in, std::vector<cv::Mat>& outs) {
infer<T>(std::vector<cv::Mat>{in}, outs);
}
void validate() {
GAPI_Assert(!out_gapi.empty() && !out_onnx.empty());
@@ -275,6 +347,12 @@ public:
const cv::Scalar mean = { 0.485, 0.456, 0.406 };
const cv::Scalar std = { 0.229, 0.224, 0.225 };
// Rois for InferList, InferList2
const std::vector<cv::Rect> rois = {
cv::Rect(cv::Point{ 0, 0}, cv::Size{80, 120}),
cv::Rect(cv::Point{50, 100}, cv::Size{250, 360}),
};
void preprocess(const cv::Mat& src, cv::Mat& dst) {
const int new_h = 224;
const int new_w = 224;
@@ -317,6 +395,55 @@ public:
dst = dst.reshape(1, {1, 1, new_h, new_w});
}
};
class ONNXWithRemap : public ONNXtest {
public:
// You can specify any size of the outputs, since we don't know infer result
// Tests validate a range with results and don't compare empty space
void validate() {
GAPI_Assert(!out_gapi.empty() && !out_onnx.empty());
ASSERT_EQ(out_gapi.size(), out_onnx.size());
const auto size = out_onnx.size();
for (size_t i = 0; i < size; ++i) {
float* op = out_onnx.at(i).ptr<float>();
float* gp = out_gapi.at(i).ptr<float>();
const auto out_size = std::min(out_onnx.at(i).total(), out_gapi.at(i).total());
GAPI_Assert(out_size != 0u);
for (size_t d_idx = 0; d_idx < out_size; ++d_idx) {
if (gp[d_idx] == -1) {
break; // end of detections
}
ASSERT_EQ(op[d_idx], gp[d_idx]);
}
}
}
};
class ONNXYoloV3MultiInput : public ONNXWithRemap {
public:
std::vector<cv::Mat> ins;
private:
virtual void SetUp() {
const int yolo_in_h = 416;
const int yolo_in_w = 416;
cv::Mat yolov3_input, shape, prep_mat;
cv::resize(in_mat1, yolov3_input, cv::Size(yolo_in_w, yolo_in_h));
shape.create(cv::Size(2, 1), CV_32F);
float* ptr = shape.ptr<float>();
ptr[0] = in_mat1.cols;
ptr[1] = in_mat1.rows;
preprocess(yolov3_input, prep_mat);
ins = {prep_mat, shape};
}
void preprocess(const cv::Mat& src, cv::Mat& dst) {
cv::Mat cvt;
src.convertTo(cvt, CV_32F, 1.f / 255.f);
toCHW(cvt, dst);
dst = dst.reshape(1, {1, 3, 416, 416});
}
};
} // anonymous namespace
TEST_F(ONNXClassificationTest, Infer)
@@ -341,15 +468,12 @@ TEST_F(ONNXClassificationTest, Infer)
validate();
}
TEST_F(ONNXtest, InferTensor)
TEST_F(ONNXClassificationTest, InferTensor)
{
useModel("classification/squeezenet/model/squeezenet1.0-9");
// Create tensor
// FIXME: Test cheks "random" image
// Ideally it should be a real image
const cv::Mat rand_mat = initMatrixRandU(CV_32FC3, cv::Size{224, 224});
const std::vector<int> dims = {1, rand_mat.channels(), rand_mat.rows, rand_mat.cols};
const cv::Mat tensor(dims, CV_32F, rand_mat.data);
cv::Mat tensor;
preprocess(in_mat1, tensor);
// ONNX_API code
infer<float>(tensor, out_onnx.front());
// G_API code
@@ -368,7 +492,7 @@ TEST_F(ONNXtest, InferTensor)
TEST_F(ONNXClassificationTest, InferROI)
{
useModel("classification/squeezenet/model/squeezenet1.0-9");
const cv::Rect ROI(cv::Point{0, 0}, cv::Size{250, 250});
const auto ROI = rois.at(1);
// ONNX_API code
cv::Mat roi_mat;
preprocess(in_mat1(ROI), roi_mat);
@@ -392,10 +516,6 @@ TEST_F(ONNXClassificationTest, InferROI)
TEST_F(ONNXClassificationTest, InferROIList)
{
useModel("classification/squeezenet/model/squeezenet1.0-9");
const std::vector<cv::Rect> rois = {
cv::Rect(cv::Point{ 0, 0}, cv::Size{80, 120}),
cv::Rect(cv::Point{50, 100}, cv::Size{250, 360}),
};
// ONNX_API code
out_onnx.resize(rois.size());
for (size_t i = 0; i < rois.size(); ++i) {
@@ -422,10 +542,6 @@ TEST_F(ONNXClassificationTest, InferROIList)
TEST_F(ONNXClassificationTest, Infer2ROIList)
{
useModel("classification/squeezenet/model/squeezenet1.0-9");
const std::vector<cv::Rect> rois = {
cv::Rect(cv::Point{ 0, 0}, cv::Size{80, 120}),
cv::Rect(cv::Point{50, 100}, cv::Size{250, 360}),
};
// ONNX_API code
out_onnx.resize(rois.size());
for (size_t i = 0; i < rois.size(); ++i) {
@@ -449,27 +565,26 @@ TEST_F(ONNXClassificationTest, Infer2ROIList)
validate();
}
TEST_F(ONNXtest, InferDynamicInputTensor)
TEST_F(ONNXWithRemap, InferDynamicInputTensor)
{
useModel("object_detection_segmentation/tiny-yolov2/model/tinyyolov2-8");
// Create tensor
// FIXME: Test cheks "random" image
// Ideally it should be a real image
const cv::Mat rand_mat = initMatrixRandU(CV_32FC3, cv::Size{416, 416});
const std::vector<int> dims = {1, rand_mat.channels(), rand_mat.rows, rand_mat.cols};
cv::Mat tensor(dims, CV_32F, rand_mat.data);
const cv::Mat in_tensor = tensor / 255.f;
cv::Mat cvt, rsz, tensor;
cv::resize(in_mat1, rsz, cv::Size{416, 416});
rsz.convertTo(cvt, CV_32F, 1.f / 255.f);
toCHW(cvt, tensor);
tensor = tensor.reshape(1, {1, 3, 416, 416});
// ONNX_API code
infer<float>(in_tensor, out_onnx.front());
infer<float>(tensor, out_onnx.front());
// G_API code
G_API_NET(YoloNet, <cv::GMat(cv::GMat)>, "YoloNet");
cv::GMat in;
cv::GMat out = cv::gapi::infer<YoloNet>(in);
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
auto net = cv::gapi::onnx::Params<YoloNet>{model_path}
auto net = cv::gapi::onnx::Params<YoloNet>{ model_path }
.cfgPostProc({cv::GMatDesc{CV_32F, {1, 125, 13, 13}}}, remapYolo)
.cfgOutputLayers({"out"});
comp.apply(cv::gin(in_tensor),
comp.apply(cv::gin(tensor),
cv::gout(out_gapi.front()),
cv::compile_args(cv::gapi::networks(net)));
// Validate
@@ -497,28 +612,26 @@ TEST_F(ONNXGRayScaleTest, InferImage)
validate();
}
TEST_F(ONNXtest, InferMultOutput)
TEST_F(ONNXWithRemap, InferMultiOutput)
{
useModel("object_detection_segmentation/ssd-mobilenetv1/model/ssd_mobilenet_v1_10");
// ONNX_API code
const auto prep_mat = in_mat1.reshape(1, {1, in_mat1.rows, in_mat1.cols, in_mat1.channels()});
infer<uint8_t>({prep_mat}, out_onnx);
infer<uint8_t>(prep_mat, out_onnx);
cv::Mat onnx_conv_out({1, 1, 200, 7}, CV_32F);
remapToIESSDOut({out_onnx[3], out_onnx[0], out_onnx[2], out_onnx[1]}, onnx_conv_out);
out_onnx.clear();
out_onnx.push_back(onnx_conv_out);
// G_API code
using SSDOut = std::tuple<cv::GMat, cv::GMat, cv::GMat, cv::GMat>;
G_API_NET(MobileNet, <SSDOut(cv::GMat)>, "ssd_mobilenet");
G_API_NET(MobileNet, <cv::GMat(cv::GMat)>, "ssd_mobilenet");
cv::GMat in;
cv::GMat out1, out2, out3, out4;
std::tie(out1, out2, out3, out4) = cv::gapi::infer<MobileNet>(in);
cv::GComputation comp(cv::GIn(in), cv::GOut(out1, out2, out3, out4));
auto net = cv::gapi::onnx::Params<MobileNet>{model_path}
.cfgOutputLayers({"out1", "out2", "out3", "out4"})
.cfgPostProc({cv::GMatDesc{CV_32F, {1, 100, 4}},
cv::GMatDesc{CV_32F, {1, 100}},
cv::GMatDesc{CV_32F, {1, 100}},
cv::GMatDesc{CV_32F, {1, 1}}}, remapSsdPorts);
out_gapi.resize(num_out);
cv::GMat out = cv::gapi::infer<MobileNet>(in);
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
auto net = cv::gapi::onnx::Params<MobileNet>{ model_path }
.cfgOutputLayers({"detection_output"})
.cfgPostProc({cv::GMatDesc{CV_32F, {1, 1, 200, 7}}}, remapSSDPorts);
comp.apply(cv::gin(in_mat1),
cv::gout(out_gapi[0], out_gapi[1], out_gapi[2], out_gapi[3]),
cv::gout(out_gapi.front()),
cv::compile_args(cv::gapi::networks(net)));
// Validate
validate();
@@ -733,6 +846,71 @@ TEST_F(ONNXMediaFrameTest, InferList2YUV)
// Validate
validate();
}
TEST_F(ONNXYoloV3MultiInput, InferConstInput)
{
useModel("object_detection_segmentation/yolov3/model/yolov3-10");
// ONNX_API code
infer<float>(ins, out_onnx);
// G_API code
using OUT = std::tuple<cv::GMat, cv::GMat, cv::GMat>;
G_API_NET(YoloNet, <OUT(cv::GMat)>, "yolov3");
auto net = cv::gapi::onnx::Params<YoloNet>{model_path}
.constInput("image_shape", ins[1])
.cfgInputLayers({"input_1"})
.cfgOutputLayers({"out1", "out2", "out3"})
.cfgPostProc({cv::GMatDesc{CV_32F, {1, 10000, 4}},
cv::GMatDesc{CV_32F, {1, 80, 10000}},
cv::GMatDesc{CV_32S, {5, 3}}}, remapYoloV3);
cv::GMat in, out1, out2, out3;
std::tie(out1, out2, out3) = cv::gapi::infer<YoloNet>(in);
cv::GComputation comp(cv::GIn(in), cv::GOut(out1, out2, out3));
out_gapi.resize(num_out);
comp.apply(cv::gin(ins[0]),
cv::gout(out_gapi[0], out_gapi[1], out_gapi[2]),
cv::compile_args(cv::gapi::networks(net)));
// Validate
validate();
}
TEST_F(ONNXYoloV3MultiInput, InferBSConstInput)
{
// This test checks the case when a const input is used
// and all input layer names are specified.
// Const input has the advantage. It is expected behavior.
useModel("object_detection_segmentation/yolov3/model/yolov3-10");
// Tensor with incorrect image size
// is used for check case when InputLayers and constInput have same names
cv::Mat bad_shape;
bad_shape.create(cv::Size(2, 1), CV_32F);
float* ptr = bad_shape.ptr<float>();
ptr[0] = 590;
ptr[1] = 12;
// ONNX_API code
infer<float>(ins, out_onnx);
// G_API code
using OUT = std::tuple<cv::GMat, cv::GMat, cv::GMat>;
G_API_NET(YoloNet, <OUT(cv::GMat, cv::GMat)>, "yolov3");
auto net = cv::gapi::onnx::Params<YoloNet>{model_path}
// Data from const input will be used to infer
.constInput("image_shape", ins[1])
// image_shape - const_input has same name
.cfgInputLayers({"input_1", "image_shape"})
.cfgOutputLayers({"out1", "out2", "out3"})
.cfgPostProc({cv::GMatDesc{CV_32F, {1, 10000, 4}},
cv::GMatDesc{CV_32F, {1, 80, 10000}},
cv::GMatDesc{CV_32S, {5, 3}}}, remapYoloV3);
cv::GMat in1, in2, out1, out2, out3;
std::tie(out1, out2, out3) = cv::gapi::infer<YoloNet>(in1, in2);
cv::GComputation comp(cv::GIn(in1, in2), cv::GOut(out1, out2, out3));
out_gapi.resize(num_out);
comp.apply(cv::gin(ins[0], bad_shape),
cv::gout(out_gapi[0], out_gapi[1], out_gapi[2]),
cv::compile_args(cv::gapi::networks(net)));
// Validate
validate();
}
} // namespace opencv_test
#endif // HAVE_ONNX