Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues 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
pull/19355/head
Maxim Pashchenkov 4 years ago committed by GitHub
parent d3bc563c6e
commit 3eaeca58da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 315 additions and 92 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      modules/gapi/src/backends/ie/giebackend.cpp
  2. 75
      modules/gapi/src/backends/onnx/gonnxbackend.cpp
  3. 324
      modules/gapi/test/infer/gapi_infer_onnx_test.cpp

8
modules/gapi/src/backends/ie/giebackend.cpp
Unescape 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};
}

75
modules/gapi/src/backends/onnx/gonnxbackend.cpp
Unescape 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;

324
modules/gapi/test/infer/gapi_infer_onnx_test.cpp
Unescape 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

Write Preview
Loading…
Cancel
Save